HEX Core and Fluid Generation Update (Clean Fields)

As we work with implicit bodies and stack up Boolean operations, it’s important to be aware of the cleanliness of our underlying fields. Using a few good practices will help to ensure that our downstream modeling and discretization operations are going to run as expected. Two really good practices to be aware of are minimizing Boolean operations early on in the modeling process and avoiding coincident surfaces in our Booleans whenever possible.

In the near future, we plan to update this course to include all of those modeling best practices, as well as flow analysis. For now, I want to walk through the modeling practices that we use in the video and highlight a couple of ways that we can improve upon those to ensure proper modeling and meshing downstream.

Let’s start by walking through the modeling practices that we used in the part one heat exchanger video. Starting with our design space, represented by this cylinder, we created a lattice throughout our heat exchanger core. We generated this raw lattice across that cylinder and then we intersected it with our initial cylindrical design space. This is an example of one of those upstream Boolean operations that isn’t necessary for our downstream modeling.

Once we created our heat exchanger core, we moved on to create our hot fluid. We generated a raw fluid using a TPMS unit cell and then we intersected that with our initial design space. Again, this is an example of a Boolean operation that we didn’t really need to use this far upstream. From there, we subtracted away our heat exchanger core to generate this initial hot fluid.

Then, to create our cold fluid, we took our initial solid design space and then we removed both this pink hot fluid and our initial heat exchanger core. That generated this cold fluid domain, but not without breaking one of our best practices: to avoid coincident surfaces in our Boolean operations. Now, before walking through a more ideal way to have modeled this, I want to take a step back and look at what coincident surfaces actually are and how they affect our underlying fields. I’ll collapse some of these blocks that we’ve opened so far, and we’ll jump over into a simpler example.

So, when we talk about coincident surfaces, we can take this example of a large cylinder and a small cylinder right inside of it. If we expand both of these blocks, we see that we’ve got two cylinders that are each 10 mm tall. And if we view maybe from the left side here, we see that the top and bottom faces of both our large cylinder and our small cylinder are going to be coincident. So, if we drop our large and small cylinders into a Boolean Subtract block, we’re left with this tube shape, as we might expect.

However, if I adjust my transparency and view the underlying field using the Field Viewer, I can probe over these values and see that outside of this tube shape, we see a signed distance field or an implicit body field as we might expect. But when we start to approach where those coincident surfaces existed, we see this 0 mm value throughout our implicit field. So, if this Boolean subtract were our final operation, that would be okay.

But say we wanted to do some further modeling downstream. So, say I wanted to take that Boolean subtract result and I wanted to offset it, maybe I want to offset it by 1 millimeter. We remember that any of these modeling operations are actually happening on the underlying implicit field of whatever surface we’re viewing. So again, if we view that implicit body field from the side like this, and we take that Boolean subtract and drop it into an Offset Body block, we’ll adjust our transparency again. And we see that we’ve actually created this solid fill outside of this fake zero because we’ve just offset our implicit body field, so that moves our surface from this fake zero all the way up to the 1 mm mark. So, our offset is actually going to look something like this.

Now, to avoid something like this, we can use this infinite cylinder approach where instead of subtracting our small cylinder from our large cylinder with a coincident surface, we can generate something like this small infinite cylinder. Now clearly, this isn’t a cylinder of infinite length, but we see that the surface of this smaller cylinder extends beyond the surface of our initial large cylinder. It’s about 5 millimeters below the bottom surface and 5 millimeters above the top surface of our large cylinder. So, if we take another Boolean Subtract block and subtract this infinite cylinder from our initial large cylinder, we get the same looking result as we got with our initial Boolean subtract operation.

But if I adjust my transparency and view the field of this new cylinder or this new tube, we see our field looks pretty different. And now we have a more true signed distance field associated with this implicit body instead of that zero surface from those coincident surfaces between our cylinders. We’ve now alleviated that concern. So if I were to take this result and offset it by 1 mm, then we maintain that tube shape because we’ve avoided that fake zero surface within our implicit body field.

Now, here’s another example of one of these coincidence surfaces. Say we’ve got a solid box like this, a section cut, so we see the inside of this is solid. And we’ve got a shelled box as well that’s a 2 mm inward shell. So if I were to use a Boolean operation, use a Boolean Subtract removing our shell from our solid box, we would get something like this, just a smaller box on the inside of here. But remember, if I use our Field Viewer, I still see that fake zero surface where our coincidence surfaces between our box and our initial shell were. So if I were to take that Boolean subtract and maybe um offset our body by, let’s say, half a millimeter, maybe section cut that, our result is actually going to look like this.

So, we see that those coincidence surfaces create these fake zeros within our implicit bodies that can lead to downstream modeling operations that may create geometries that we’re not expecting. So, jumping back over into our heat exchanger example, I want to highlight a couple of adjustments that we can make in our modeling process to generate better fields and make sure that downstream we’re avoiding modeling issues as well as meshing and export issues. So, what we can do here is still use our initial design space and generate our initial raw lattice. That’s later going to become the walls of our heat exchanger core.

But now we’re going to generate our fluids differently. So, we created our raw fluid earlier and we’ll take our initial solid design space and remove both our raw fluid and our raw lattice from that design space. So, we’re left with something like this. So, by modeling this way, we’ve avoided using our initial Boolean intersect that we had previously used upstream and we just started with a nice clean design space and remove two lattices that in this case we’re going to count as those, uh, kind of infinite geometries that we’re removing.

We know that the surface of our raw fluid is right at the mid-surface of our raw lattice and the bounds of both our raw fluid and our raw lattice fall well outside of the bounds of our initial design space. So here we’re implementing both of those best practices that we discussed: we’re minimizing our upstream Boolean operations and we’re avoiding creating Booleans on coincidence surfaces.

Now, we’re going to take a similar approach when we create our new hot fluid down here. So again, we’ll take our initial design space, which is just that solid cylinder, and we’ll remove the negative implicit scalar field of our raw fluid, so the negative field of this lattice, as well as that same raw lattice that we were using for our heat exchanger core. So, this is going to generate our hot fluid. We’ve also got our new cold fluid, and will retain that heat exchanger core. So again, these are some good practices to watch out for as you start to model your own heat exchangers, as well as other geometry in nTop. In the near future, you can expect to see updates to this heat exchanger course to reflect both best practices for modeling, as well as flow analysis.