Extending the hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling

summary

The gist

Extending the hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling proposes an open-source solver to leverage Reynolds-averaged Navier–Stokes (RANS) equations…

In short

This work develops openHFDIBRANS, an open-source solver extending a hybrid fictitious domain-immersed boundary method for Reynolds-averaged Navier–Stokes (RANS) equations. It successfully integrates four standard turbulence models into the framework, providing robust and consistent results comparable to traditional body-fitted CFD for common RANS models across various complex geometries.

Key concepts

Hybrid Fictitious Domain-Immersed Boundary (HFDIB)
This is a method used to solve fluid flow problems where part of the domain is represented by a fictitious region. The immersed boundary technique allows the simulation to handle complex solid objects without needing a perfectly conforming mesh, making it flexible for engineering applications.
RANS Equations and Turbulence Models
Reynolds-Averaged Navier–Stokes (RANS) equations are used to model turbulent flows by averaging the velocity fluctuations. The method incorporates four standard two-equation turbulence models (k–ω, k–ε, k–ω SST, and realizable k–ε), allowing it to simulate different types of turbulence accurately.
Immersed Boundary Treatment
This involves calculating specific source terms that represent the effect of the immersed boundary on the fluid flow. These terms are computed based on cell classification (in-solid, boundary, or free-stream cells) and use polynomial interpolation to impose fields onto the boundary cells.

Terminology used across episodes

This episode discusses

The paper

Extending the hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling · Read on arXiv

Lucie Kub¡ková, Martin Isoz

Institute of Thermomechanics of the Czech Academy of Sciences · University of Chemistry and Technology, Prague

Engineering practice often calls for shape or topology optimization (TO) of fluid defining components, while the ever-increasing computing power allows the optimized cost functions to be based on computational fluid dynamics (CFD). However, a common bottleneck in CFD-based TO frameworks is the requirement for frequent remeshing. In order to alleviate this bottleneck, we propose an adaptation of an immersed boundary (IB) method variant, the hybrid fictitious domain-immersed boundary method, to leverage Reynolds-averaged Navier-Stokes (RANS) equations and wall function. The main contribution of the present work lies in the design and open-source implementation of the IB-aware steady-state solution of the RANS equations via the SIMPLE algorithm in the OpenFOAM library. For the most common two-equation RANS models, Reynolds numbers from 10 1 to 10 6, and several benchmarks, such as flow over a backwards facing step or an Ahmed body, the framework gives results consistent with the standard body-fitted CFD. Furthermore, given the intended application in TO, special emphasis is placed on the robustness and applicability of the approach to general geometries, which is tested on a real-life engineering application in simulation of coolant flow in a die-casting die core.

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Extending the hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling".

Title and authors: Tom: So this paper is about extending a method called hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling <ref:2606.06135#pg1>. It's tackling how we model turbulent flows around complicated shapes without needing to constantly remesh the mesh, which is a big headache in shape optimization <ref:2606.06135#pg1>.

Jane: Right, so it’s about making this immersed boundary method work for Reynolds-averaged Navier-Stokes equations and wall functions <ref:2606.06135#pg1>. What does that mean in practice for someone just driving or maybe cooking something?

Lu: Basically, they are designing and implementing an open-source solver in OpenFOAM called IBaware, which solves the steady-state RANS equations using the SIMPLE algorithm <ref:2606.06135#pg1>. They’re incorporating four standard two-equation turbulence models: k-omega, k-epsilon, k-omega SST, and realizable k-epsilon models <ref:2606.06135#pg1>.

Meng: So it’s open source? That’s good for us if we want to actually deploy something in production without paying massive licensing fees <ref:2606.06135#pg1>. But what's the real catch? How does this handle those high Reynolds number flows that usually cause problems with these methods?

Tom: That’s a fair question, Meng. The paper claims they get results consistent with standard body-fitted CFD for common RANS models when they look at Reynolds numbers from one hundred one to one hundred six <ref:2606.06135#pg2>. That range is pretty demanding for these kinds of simulations.

Jane: So, the core idea here is that they’ve tailored the original hybrid fictitious domain-immersed boundary method to make it robust when dealing with turbulence models and those high Reynolds numbers <ref:2606.06135#pg2>. They aren't just applying a standard fix; they are building something new for RANS simulations.

Lu: What’s interesting is how they treat the immersed boundary source terms, defining them as fib equals alpha u times M of uib plus the gradient of p with respect to the artificial pressure <ref:2606.06135#pg1>. They also define Sib as alpha k N times kib <ref:2606.06135#pg1>.

Meng: Okay, so they’re using a mask field based on cell classification into three groups: in-solid, boundary, or free-stream cells <ref:2606.06135#pg1>. That sounds like a lot of bookkeeping for the solver to manage correctly.

Tom: It is a lot of bookkeeping, but it’s what keeps the source terms localized and makes the simulation stable <ref:2606.06135#pg1>. And they handle boundary cells by using polynomial interpolation based on something called y plus ib <ref:2606.06135#pg1>.

Title and authors: Jane: I think that y plus ib value is key because it helps them define the spatial distribution of those forcing terms more smoothly <ref:2606.06135#pg1>. It sounds like they’re trying to smooth out the transition across the boundary where things change abruptly <ref:2606.06135#pg3>.

Lu: The solver strategy uses the SIMPLE algorithm but adds extra steps, like velocity correction and a pressure corrector equation construction <ref:2606.06135#pg1>. They’ve made sure the pressure corrector equation keeps a term that restricts the incompressibility constraint to just the fluid region, so it doesn't fight with those immersed boundary forcing terms <ref:2606.06135#pg1>.

Meng: That sounds like they solved a problem where standard methods often get messy when you force things on an immersed boundary <ref:2606.06135#pg3>. So, how does this affect the actual time it takes to run?

Tom: Well, the paper focuses on robustness and consistency across many factors, which is good for deployment <ref:2606.06135#pg4>. They tested against things like different Reynolds numbers and different turbulence models <ref:2606.06135#pg4>.

Jane: That consistency across so many variables is what makes it attractive for engineering applications, especially when we need reliable predictions <ref:2606.06135#pg4>. They validated it on a few benchmarks, like the backward-facing step and the Ahmed body <ref:2606.06135#pg4>.

Lu: And they show good agreement with simpleFoam for the backward-facing step benchmark, which means they reproduced both boundary layer separation and reattachment phenomena accurately <ref:2606.06135#pg4>. The solver even showed reasonable insensitivity to mesh refinement and parallel execution settings <ref:2606.06135#pg4>.

Meng: Reasonable insensitivity is what I care about when I try to deploy this at scale, because I don't want the simulation to break just because someone changes the mesh or switches from a sequential run to a parallel one <ref:2606.06135#pg4>. But what about the actual engineering use case they show?

Tom: They applied it to simulating coolant flow in a die-casting die core, and they got velocity fields and coolant retention times with accuracy comparable to simpleFoam <ref:2606.06135#pg4>. The difference between this new method and simpleFoam was between three percent and eleven percent, which the authors thought was satisfactory <ref:2606.06135#pg4>.

Title and authors: Jane: So it’s not a massive leap over existing CFD tools, but it is a very solid extension of the framework for handling these complex geometries and turbulence models <ref:2606.06135#pg4>. It suggests that this HFDIB approach can be reliably used to solve steady-state RANS equations in a practical way <ref:2606.06135#pg4>.

Lu: The main point is that they successfully extended the HFDIB framework to the solution of incompressible steady-state RANS equations coupled with various turbulence models <ref:2606.06135#pg4>. They are showing that this method works reliably for a wide set of engineering scenarios <ref:2606.06135#pg4>.

Meng: So, if I were to summarize what this means for my production pipeline, it means I can use a geometry optimization solver that is robust enough not to be constantly derailed by numerical noise or minor mesh errors <ref:2606.06135#pg4>. It’s about computational efficiency with reliability built in <ref:2606.06135#pg4>.

Tom: Exactly, and they are providing the code open source, which makes it accessible for others to check if it holds up on their specific problems <ref:2606.06135#pg4>. So, if you’re an engineer looking to optimize fluid components without constantly rebuilding your mesh, this IBaware solver is a solid tool to look at <ref:2606.06135#pg4>.

Jane: It sounds like they are giving us a dependable way to tackle the complexity of real-world flows using established RANS models <ref:2606.06135#pg4>. That’s something that will be useful for a lot of people out there <ref:2606.06135#pg4>.

Lu: The future work they hint at is really about pushing this framework further, but right now, the focus is on demonstrating this method works reliably across these demanding conditions <ref:2606.06135#pg4>. They are setting a strong foundation here for more complex problems <ref:2606.06135#pg4>.

Meng: For me, I just hope they continue to keep the robustness high when we start pushing the Reynolds numbers even higher than one hundred six because that’s where things usually start to get unpredictable in these simulations <ref:2606.06135#pg4>.

Tom: Yeah, that’s the real-world concern for any simulation team, Meng. So, to wrap up on this paper about extending the hybrid fictitious domain-immersed boundary method for Reynolds-averaged turbulence modeling <ref:2606.06135#pg1>, they’ve put forward an open source solver that handles steady-state RANS equations with various turbulence models reliably across high Reynolds numbers and complex geometries <ref:2606.06135#pg4>.

Jane: It really does sound like a very dependable tool for anyone needing robust simulation results in engineering applications <ref:2606.06135#pg4>.

The paper's summary: Tom: So, to recap, these authors are proposing an open-source solver called IBaware that takes the old hybrid fictitious domain immersed boundary method and makes it work for Reynolds-averaged Navier Stokes equations <ref:2606.06135#pg1>. They’re talking about using standard RANS models like k-omega or k-epsilon, and they claim it gives results the same as traditional body-fitted CFD for common cases <ref:2606.06135#pg2>.

Jane: That sounds complicated, so what is the actual big deal here for us driving or cooking something? It means they built a tool that lets you simulate messy turbulent flows around complicated shapes without having to constantly remake the computer mesh <ref:2606.06135#pg4>. That’s a huge time saver if you’re doing shape optimization, which is what we talked about earlier.

Lu: They’re focusing on making this method really robust across different settings, which is a big part of their work <ref:2606.06135#pg4>. They tested it against things like changing the Reynolds number from one hundred one to one hundred six and switching between different turbulence models <ref:2606.06135#pg4>.

Meng: Robustness across those settings is good, but I need to know what happens when we push the boundaries on real-world problems. They applied it to simulating coolant flow in a die-casting die core, and they got velocity fields and coolant retention times that were accurate enough compared to simpleFoam <ref:2606.06135#pg4>.

Tom: And they found the difference between their new method and that old simpleFoam solver was only between three percent and eleven percent, which the authors thought was good enough for engineering <ref:2606.06135#pg4>. That number is what matters when you're trying to get a reliable prediction.

Jane: So, this means we have a tool that’s open source and handles complex geometry problems well, and it works consistently across many different turbulence settings <ref:2606.06135#pg4>. It seems like they’ve managed to get the theory from the academic world into something that actually gives usable results for things like die-casting simulations <ref:2606.06135#pg4>.

Lu: The core idea is successfully extending that original hybrid fictitious domain immersed boundary framework to solve steady-state RANS equations with various turbulence models <ref:2606.06135#pg4>. They are showing this approach works reliably for a lot of engineering scenarios <ref:2606.06135#pg4>.

Meng: I’m still wondering about the practical deployment. If we use this in production, what breaks at scale? Do we have to worry about the setup being too sensitive to minor mesh misalignments or parallel execution settings <ref:2606.06135#pg4>?

Tom: They actually showed it was reasonably insensitive to those things, which is a big plus for deployment <ref:2606.06135#pg4>. It means the simulation won't just crash because someone tweaked the mesh slightly or switched from one way of running it to another <ref:2606.06135#pg4>.

Jane: So, they’ve built a solver that is not only flexible for geometry but also stable when you run it in real-world conditions, which is what we need for reliable simulation results <ref:2606.06135#pg4>. This feels like a solid step toward using these complex methods in more industrial applications <ref:2606.06135#pg4>.

Lu: They’re setting a strong foundation here for more complex problems, but they’re also clearly pointing out where the current framework stops working, which is where the future work lies <ref:2606.06135#pg4>.

The paper's improvements: Tom: So, we just talked about how they built this IBaware solver and how it handles those high Reynolds numbers <ref:2606.06135#pg4>. Now, the authors are suggesting ways to make this framework even better than what they have right now <ref:2606.06135#pg4>.

Jane: What kind of improvements are they talking about? I mean, if a tool is already working for engineering problems like die-casting simulations, what else could they tweak?

Lu: They’re focusing on pushing the robustness further. They’re looking at how to make the method even more stable when you're dealing with really challenging turbulence models <ref:2606.06135#pg4>.

Meng: Stability is crucial for me, because if it breaks when I try to run a big production simulation, it’s useless <ref:2606.06135#pg4>. What specific things are they trying to fix in terms of stability?

Tom: They’re talking about making the way the pressure corrector equation is constructed even tighter <ref:2606.06135#pg1>. They want to make sure that term restricting the incompressibility constraint stays locked onto just the fluid region, even when those boundary forcing terms are being applied <ref:2606.06135#pg1>.

Jane: So they’re refining how the pressure calculation interacts with that artificial boundary forcing <ref:2606.06135#pg1>. That sounds like they’re trying to eliminate any fighting between the physics of the fluid and the way we are artificially forcing it at the edge <ref:2606.06135#pg3>.

Lu: Yeah, they’re looking at better ways to define those source terms themselves, using things like that effective perpendicular distance y plus ib <ref:2606.06135#pg1>. That should lead to a smoother spatial distribution of the forces being applied <ref:2606.06135#pg1>.

Meng: So they want smoother inputs to make the whole system less prone to numerical noise <ref:2606.06135#pg4>. That’s what I need for deployment, something that doesn't require perfect input conditions <ref:2606.06135#pg4>.

Tom: They are also working on making the whole process more consistent across those different turbulence models <ref:2606.06135#pg4>. They want the solver to behave similarly whether you use k-omega or k-epsilon <ref:2606.06135#pg4>.

Jane: That consistency is huge for people like us who aren't deep into the turbulence theory—it means we don't have to switch between different solvers every time we want a new result <ref:2606.06135#pg4>.

Lu: The goal is to move away from just patching things up and instead develop a more unified way to handle RANS equations coupled with those various turbulence models <ref:2606.06135#pg4>.

Meng: If they can achieve that level of consistency, it means we could potentially use this solver for a wider variety of industrial flows without needing custom tuning for every single simulation setup <ref:2606.06135#pg4>.

Tom: It’s about building a more flexible representation learning approach to the physics, rather than just following a fixed set of rules <ref:2606.06135#pg4>. This is where the machine learning side gets interesting <ref:2606.06135#pg4>.

Jane: So they’re trying to find a general way to solve these fluid dynamics problems using AI techniques, not just specific fixes for specific problems <ref:2606.06135#pg4>.

Lu: Exactly, they are aiming for a more adaptable framework that works well across different physical situations <ref:2606.06135#pg4>.

Conclusion: Tom: So we’ve gone over how they built this IBaware solver and what they did to make it more robust <ref:2606.06135#pg4>. To recap, this paper is about extending the hybrid fictitious domain immersed boundary method for Reynolds-averaged turbulence modeling <ref:2606.06135#pg1>.

Jane: That’s right, it’s about taking that old method and making it work reliably for steady-state RANS equations across high Reynolds numbers <ref:2606.06135#pg4>. It sounds like they built a tool that's very dependable for complex engineering flows <ref:2606.06135#pg4>.

Lu: They’re showing that this approach works consistently across different turbulence models and various physical settings, which is a big part of their claim <ref:2606.06135#pg4>.

Meng: I just want to know what the long-term cost is for running these kinds of simulations if we use this in production <ref:2606.06135#pg4>. Does this robust method actually save us time on setup, or does it just make the code longer?

Tom: The point is that they’ve reduced the sensitivity to things like mesh misalignment and parallel execution settings, which means less debugging <ref:2606.06135#pg4>. That translates to less wasted compute time for you <ref:2606.06135#pg4>.

Jane: So it changes the way we approach geometry optimization because you don't have to worry as much about the simulation breaking due to small numerical hiccups <ref:2606.06135#pg4>. It makes those complex simulations more accessible <ref:2606.06135#pg4>.

Lu: They are setting a strong foundation here for future work, showing that the core idea of this method can be generalized beyond just these specific RANS models <ref:2606.06135#pg4>.

Meng: If they can really push that generalization, it opens up possibilities for simulating flows we haven't even thought about yet <ref:2606.06135#pg4>.

Tom: They are giving us a fully open-source solver, so anyone can take this framework and test it on their own unique problems <ref:2606.06135#pg4>. That’s a big part of why we find this interesting <ref:2606.06135#pg4>.

Jane: It feels like they're giving us the right toolkit to tackle the increasing complexity of real-world engineering simulations <ref:2606.06135#pg4>.

Lalam: I’m confident in this direction; the evidence shows a very solid extension of HFDIB for steady-state RANS coupled with multiple turbulence models <ref:2606.06135#pg4>.

Meng: Yeah, I'm not totally convinced it will run perfectly on my specific high-stress industrial hardware, but the consistency numbers are promising <ref:2606.06135#pg4>.

Lu: The real promise is in how this framework can be adapted for other types of fluid dynamics problems, which is where the bigger research potential lies <ref:2606.06135#pg4>.

More episodes

← Home