FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments
summary
The gist
FlowMLLab is an open-source framework that connects validated fluidmechanics solvers to scientific machine-learning experiments under a reproducible contract Its computational fluid dynamics (CFD)…
In short
FlowMLLab is an open-source framework connecting fluid mechanics solvers to machine learning experiments using a reproducible contract. It uses CFD and DSMC pathways to generate validated data, employs case-wise partitions to prevent leakage, and compares learned models against non-neural baselines. The system emphasizes traceable evidence over black-box fitting.
Key concepts
- Reproducibility Contract
- This is a set of strict rules governing the entire experiment. It dictates how data is qualified, how cases are partitioned to prevent information leakage, and which non-neural models serve as fixed baselines. This ensures that any performance gains from machine learning are measurable and not due to lucky parameter choices.
- Continuum Pathway
- This pathway uses traditional fluid dynamics methods like Ghia centerlines and Botella–Peyret pressure profiles to generate reference data. Errors are measured using specific norms, like the relative discrete L2 norm, providing a rigorous physical benchmark for comparison against machine learning predictions.
- Inference Advantage
- The framework demonstrates that trained models can be evaluated extremely quickly after training. A three-seed ensemble achieves velocity and pressure errors of 1.4% and 4.3% respectively in the blind Re=275 case, while the reference CPU solution takes 8 seconds, resulting in an inference-to-solver speed ratio of about 870,000.
Terminology used across episodes
This episode discusses
- FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments · Paper Radio
The paper
FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments · Read on arXiv
University of Massachusetts Amherst
FlowMLLab is an open-source Python framework for scientific machine learning in thermal-fluid and aerospace engineering, covering incompressible, compressible and rarefied flows. Its 22 weeks comprise 51 notebooks and 35 lectures. Solvers and molecular sampling underpin field prediction, uncertainty quantification and reduced-order modeling. Proper orthogonal decomposition (POD) and deep operator networks (DeepONets), including POD-DeepONet, connect operating conditions to flow fields alongside Fourier neural operators. Physics-informed neural networks infer solutions and constitutive coefficients. Geometry-conditioned models, including the point-cloud DeepONet variant Geom-DeepONet, handle changing domains. Aerospace applications address airfoil shock/vortex identification, rarefied-gas modeling, nozzle flow prediction and supersonic body design. Complementary thermal-fluid examples cover unsteady wakes, hydrofoil vapor clouds and noisy particle observations. Attention mechanisms support sparse-sensor reconstruction, autoregressive prediction and transfer assessment, alongside character-level language modeling. Complete-case evaluation excludes tests from selection; execution notes identify retained research outputs. A worked extension embeds a learned monotone relation for a fixed manufactured Carreau fluid in channel momentum balance. At three unseen in-support pressure gradients, it outperforms profile-interpolation and fitted-Newtonian controls with different information or priors.
Transcript
Introduction to the show: ident: Physics. The day in general physics: instruments, methods and results across the field.
Kai: I'm Kai.
Mira: And I'm Mira, here with Lev.
Kai: We're looking at the paper: "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments".
Title and authors: Kai: So we're looking at this paper now about "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments." It’s essentially a system designed to connect established fluid mechanics solvers with scientific machine learning experiments under a very strict contract.
Mira: Right, it sets up this reproducible contract, which means you have validated fluid mechanics solvers generating cavity data on one side, and direct simulation Monte Carlo providing evidence for rarefied flow on the other side. That’s the core setup they’re describing in "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments."
Lev: I'm curious about how they enforce that contract, because connecting two different simulation types is usually where things get messy when you try to use machine learning for something like this.
Kai: Well, the paper talks about case wise partitions which prevent leakage between cases in the learning process. They also use matched non neural baselines to determine if any of these learning methods actually offers a measurable advantage over just using traditional methods.
Mira: So they aren't just fitting curves to data; they are testing whether the machine learning part is genuinely useful by holding everything else constant across those case wise partitions. That’s a big step toward making sure the results are traceable, which is something I really value as a theorist.
Lev: From an engineering standpoint, that means if we introduce a new learned kinetic closure or some other model, we have to prove it against these fixed evidence targets before we even consider deploying it. It makes the evaluation process very rigorous for real hardware testing later on.
Kai: Exactly. They retain numerical provenance throughout the entire process, which means you can always look back and see exactly where each piece of data came from—whether it’s a solver acceptance record or a specific simulation run.
Mira: And they have these blind case protocols, which means the architecture selection, the order of operations for things like reduced order models or early stopping are all fixed before you start evaluating the learning component. That removes a lot of guesswork from the experiment design.
Lev: That fixed setup is crucial because it isolates variables so that we can actually measure if the learning part improves things, instead of just seeing a small loss number drop in isolation. It’s about finding a measurable advantage against something that already works reasonably well.
Kai: They use Python components to regenerate every figure and sixteen tutorials use the same interfaces as the command line tools, which really helps with reproducibility for anyone trying to replicate this work.
Mira: And they have specific data structures too, like the cavity archive which stores velocity, pressure, streamfunction, and vorticity on a sixty five by sixty five grid for Reynolds numbers ranging from one hundred to four hundred. That’s a concrete piece of evidence they are using as their baseline here in "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments."
Lev: Sixty five by sixty five is a relatively small grid, which makes sense given the focus on the continuum pathway being restricted to a two dimensional lid driven cavity. It keeps the reference data manageable for testing.
Kai: The paper also details their validation protocols, where they combine Ghia centerlines and Botella–Peyret pressure profiles with wall root mean square error and discrete divergence for their continuum pathway tests.
Mira: That combination sounds like a very thorough check because it covers both the velocity field structure using centerlines and the pressure recovery using those specific profiles to measure errors.
Lev: And then they have a DSMC pathway that tests replicate spread, higher moments, and maximum pointwise differences for their rarefied flow evidence. So they’re checking different kinds of physical metrics depending on which simulation type you are looking at.
Kai: When we look at the model evaluation metrics, they use a coordinate multilayer perceptron or MLP that maps the Reynolds number and coordinates x and y to the velocity, vorticity, and pressure fields using a hyperbolic tangent activation function.
Mira: And then they combine that with something called POD deeponet which uses a fixed spatial basis combined with a coefficient branch to separate the representation error from the prediction error. That’s an interesting way to decompose where the model is failing.
Lev: If we were running this on real hardware, I'd worry about how fast that coordinate network inference is actually going, especially when you have all those different inputs and layers involved.
Kai: The paper shows a pretty strong inference advantage here; a three seed ensemble for the blind Reynolds number twenty seven five case attains relative L2 errors of one point four two three percent in velocity and four point two six four percent in pressure for that case.
Mira: So it’s not just about accuracy on the training data, but how quickly you can get a result when you have a new input, which is what they are emphasizing here.
Lev: A relative L2 error of one point four two three percent sounds good when compared to what we typically see in these kinds of physics-informed models, assuming the underlying assumptions hold true.
Kai: And the paper shows that this advantage is rapid parameter to field evaluation after offline training; a three seed sixty five by sixty five ensemble requires approximately zero point nine three milliseconds, whereas the reference CPU solution takes about eight seconds in their measured environment.
Mira: That inference to solver speed ratio of approximately eight point seven times ten cubed is quite substantial for this type of complex fluid dynamics problem. It shows that the reduced order script is very fast compared to solving the full equation from scratch every time you want a new field.
Lev: Eight point seven times ten cubed is a large number, but it’s important to remember that this speed ratio depends entirely on the hardware context and how well those fixed baselines were established.
Kai: They are also testing learned kinetic closures, which are models that solve local maps after they've been deployed into their time advancing solvers. The collision and Fokker-Planck networks handle these local maps.
Mira: That’s where the uncertainty gets tricky; the paper mentions that DSMC receives direct literature validation before neural collision transfer, which is a good way to anchor those kinetic models in established physics.
Lev: If we are talking about kinetic maps, we need to be really careful about how reliable that transfer is once you move it from a simulation environment to something meant for real-time inference.
Kai: They use relative discrete L2 norm epsilon two equals the predicted minus the reference squared divided by the reference squared, where q is the scalar field and i identifies one of N locations. That’s their metric for field error across all these different methods.
Mira: So they aren't just looking at a single error number; they are quantifying how that error varies across every single point in the computed field, which is much more informative than just an average.
Lev: Quantifying it at N locations means you’re dealing with N different local errors, and you have to make sure those local tests are robust enough to cover all the failure modes of the model.
Kai: The paper also shows that saved artifacts support regression testing through declared scalar tolerances, array shape checks, finite value checks and explicit wall condition assertions.
Mira: That’s good because it means you can set up automated gates during continuous integration to ensure that when someone updates the code or data, it doesn't accidentally violate those physical constraints.
Lev: I agree with that; having those explicit assertions helps catch subtle numerical instabilities early on before they become problems in a real deployment scenario.
Kai: So, looking at the whole picture of "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments," it’s about building a traceable path from numerical fluid mechanics to validated scientific machine learning.
Mira: It’s about emphasizing that evidence rather than just black box curve fitting, which is the core philosophy driving the whole framework.
Lev: The implication for real hardware is that we need this kind of rigorous validation harness before we can trust any of these accelerated solvers when they move out of a research notebook and into a production environment.
Kai: For now, it seems like they’ve created a very solid experimental harness here that connects solvers to their benchmark data with a strict contract governing solver output and data qualification.
Mira: It provides continuous integration through those checks on three different Python versions, which means the system is built to be robust across different software environments.
Lev: And I think the future work they mention, like addressing multi-parameter continuum families with geometry aware representations, points toward where this can eventually go for broader applications.
Kai: It does suggest that we need to look at uncertainty calibration and explicit out of distribution detection before those broader operators can be assessed reliably in a practical setting.
Mira: And the kinetic benchmarks they plan to add, spanning several Knudsen and Mach numbers, will be necessary to ensure the sampling uncertainty is properly propagated into every model comparison.
Lev: I think having those specific kinetic benchmarks will really test whether these learned collision or closure models remain reliable after they've been deployed in a closed loop operation.
Kai: So, to wrap up on "FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments," it’s providing a reproducible path from numerical fluid mechanics to validated scientific machine learning under a contract governing solver output, data qualification, case wise partitions and baselines.
Mira: It's all about making sure the physical evidence is what drives the model selection process rather than just minimizing some abstract loss function.
Lev: And I think this framework contributes an experimental harness rather than proposing another neural architecture, which keeps it grounded in the physics we already understand well.
The paper's summary: Kai: So, we're talking about FlowMLLab now, which is basically this open source framework that connects validated fluid mechanics solvers to scientific machine learning experiments under a very strict contract.
Mira: It sets up this contract where you have fluid dynamics generating cavity data on one side and direct simulation Monte Carlo providing evidence for rarefied flow on the other side.
Lev: I'm curious about how they enforce that contract, because connecting two different simulation types is usually where things get messy when you try to use machine learning for something like this.
Kai: Well, the paper talks about case wise partitions which prevent leakage between cases in the learning process. They also use matched non neural baselines to determine if any of these learning methods actually offers a measurable advantage over just using traditional methods.
Mira: So they aren't just fitting curves to data; they are testing whether the machine learning part is genuinely useful by holding everything else constant across those case wise partitions. That’s a big step toward making sure the results are traceable, which is something I really value as a theorist.
Lev: From an engineering standpoint, that means if we introduce a new learned kinetic closure or some other model, we have to prove it against these fixed evidence targets before we even consider deploying it. It makes the evaluation process very rigorous for real hardware testing later on.
Kai: Exactly. They retain numerical provenance throughout the entire process, which means you can always look back and see exactly where each piece of data came from—whether it’s a solver acceptance record or a specific simulation run.
Mira: And they have these blind case protocols, which means the architecture selection, the order of operations for things like reduced order models or early stopping are all fixed before you start evaluating the learning component. That removes a lot of guesswork from the experiment design.
Lev: That fixed setup is crucial because it isolates variables so that we can actually measure if the learning part improves things, instead of just seeing a small loss number drop in isolation. It’s about finding a measurable advantage against something that already works reasonably well.
Kai: They use Python components to regenerate every figure and sixteen tutorials use the same interfaces as the command line tools, which really helps with reproducibility for anyone trying to replicate this work.
Mira: And they have specific data structures too, like the cavity archive which stores velocity, pressure, streamfunction, and vorticity on a sixty five by sixty five grid for Reynolds numbers ranging from one hundred to four hundred. That’s a concrete piece of evidence they are using as their baseline here in FlowMLLab.
Lev: Sixty five by sixty five is a relatively small grid, which makes sense given the focus on the continuum pathway being restricted to a two dimensional lid driven cavity. It keeps the reference data manageable for testing.
Kai: The paper also details their validation protocols, where they combine Ghia centerlines and Botella–Peyret pressure profiles with wall root mean square error and discrete divergence for their continuum pathway tests.
Mira: That combination sounds like a very thorough check because it covers both the velocity field structure using centerlines and the pressure recovery using those specific profiles to measure errors.
Lev: And then they have a DSMC pathway that tests replicate spread, higher moments, and maximum pointwise differences for their rarefied flow evidence. So they’re checking different kinds of physical metrics depending on which simulation type you are looking at.
Kai: When we look at the model evaluation metrics, they use a coordinate multilayer perceptron or MLP that maps the Reynolds number and coordinates x and y to the velocity, vorticity, and pressure fields using a hyperbolic tangent activation function.
Mira: And then they combine that with something called POD deeponet which uses a fixed spatial basis combined with a coefficient branch to separate the representation error from the prediction error. That’s an interesting way to decompose where the model is failing.
Lev: If we were running this on real hardware, I'd worry about how fast that coordinate network inference is actually going, especially when you have all those different inputs and layers involved.
Kai: The paper shows a pretty strong inference advantage here; a three seed ensemble for the blind Reynolds number twenty seven five case attains relative L2 errors of one point four two three percent in velocity and four point two six four percent in pressure for that case.
Mira: So it’s not just about accuracy on the training data, but how quickly you can get a result when you have a new input, which is what they are emphasizing here.
Lev: A relative L2 error of one point four two three percent sounds good when compared to what we typically see in these kinds of physics-informed models, assuming the underlying assumptions hold true.
Kai: And the paper shows that this advantage is rapid parameter to field evaluation after offline training; a three seed sixty five by sixty five ensemble requires approximately zero point nine three milliseconds, whereas the reference CPU solution takes about eight seconds in their measured environment.
Mira: That inference to solver speed ratio of approximately eight point seven times ten cubed is quite substantial for this type of complex fluid dynamics problem. It shows that the reduced order script is very fast compared to solving the full equation from scratch every time you want a new field.
Lev: Eight point seven times ten cubed is a large number, but it’s important to remember that this speed ratio depends entirely on the hardware context and how well those fixed baselines were established.
Kai: They are also testing learned kinetic closures, which are models that solve local maps after they've been deployed into their time advancing solvers. The collision and Fokker-Planck networks handle these local maps.
Mira: That’s where the uncertainty gets tricky; the paper mentions that DSMC receives direct literature validation before neural collision transfer, which is a good way to anchor those kinetic models in established physics.
Lev: If we are talking about kinetic maps, we need to be really careful about how reliable that transfer is once you move it from a simulation environment to something meant for real-time inference.
Kai: They use relative discrete L2 norm epsilon two equals the predicted minus the reference squared divided by the reference squared, where q is the scalar field and i identifies one of N locations. That’s their metric for field error across all these different methods.
Mira: So they aren't just looking at a single error number; they are quantifying how that error varies across every single point in the computed field, which is much more informative than just an average.
Lev: Quantifying it at N locations means you’re dealing with N different local errors, and you have to make sure those local tests are robust enough to cover all the failure modes of the model.
Kai: The paper also shows that saved artifacts support regression testing through declared scalar tolerances, array shape checks, finite value checks and explicit wall condition assertions.
Mira: That’s good because it means you can set up automated gates during continuous integration to ensure that when someone updates the code or data, it doesn't accidentally violate those physical constraints.
Lev: I agree with that; having those explicit assertions helps catch subtle numerical instabilities early on before they become problems in a real deployment scenario.
Kai: So, looking at the whole picture of FlowMLLab, it’s about building a traceable path from numerical fluid mechanics to validated scientific machine learning.
Mira: It’s about emphasizing that evidence rather than just black box curve fitting, which is the core philosophy driving the whole framework.
Lev: And I think this framework contributes an experimental harness rather than proposing another neural architecture, which keeps it grounded in the physics we already understand well.
Kai: The implication for real hardware is that we need this kind of rigorous validation harness before we can trust any of these accelerated solvers when they move out of a research notebook and into a production environment.
The paper's improvements: Kai: So we're looking at FlowMLLab now, which is this open source framework that connects validated fluid mechanics solvers to scientific machine learning experiments under a very strict contract.
Mira: It sets up this contract where you have fluid dynamics generating cavity data on one side and direct simulation Monte Carlo providing evidence for rarefied flow on the other side.
Lev: I'm curious about how they enforce that contract, because connecting two different simulation types is usually where things get messy when you try to use machine learning for something like this.
Kai: Well, the paper talks about case wise partitions which prevent leakage between cases in the learning process. They also use matched non neural baselines to determine if any of these learning methods actually offers a measurable advantage over just using traditional methods.
Mira: So they aren't just fitting curves to data; they are testing whether the machine learning part is genuinely useful by holding everything else constant across those case wise partitions. That’s a big step toward making sure the results are traceable, which is something I really value as a theorist.
Lev: From an engineering standpoint, that means if we introduce a new learned kinetic closure or some other model, we have to prove it against these fixed evidence targets before we even consider deploying it. It makes the evaluation process very rigorous for real hardware testing later on.
Kai: Exactly. They retain numerical provenance throughout the entire process, which means you can always look back and see exactly where each piece of data came from—whether it’s a solver acceptance record or a specific simulation run.
Mira: And they have these blind case protocols, which means the architecture selection, the order of operations for things like reduced order models or early stopping are all fixed before you start evaluating the learning component. That removes a lot of guesswork from the experiment design.
Lev: That fixed setup is crucial because it isolates variables so that we can actually measure if the learning part improves things, instead of just seeing a small loss number drop in isolation. It’s about finding a measurable advantage against something that already works reasonably well.
Kai: They use Python components to regenerate every figure and sixteen tutorials use the same interfaces as the command line tools, which really helps with reproducibility for anyone trying to replicate this work.
Mira: And they have specific data structures too, like the cavity archive which stores velocity, pressure, streamfunction, and vorticity on a sixty five by sixty five grid for Reynolds numbers ranging from one hundred to four hundred. That’s a concrete piece of evidence they are using as their baseline here in FlowMLLab.
Lev: Sixty five by sixty five is a relatively small grid, which makes sense given the focus on the continuum pathway being restricted to a two dimensional lid driven cavity. It keeps the reference data manageable for testing.
Kai: The paper also details their validation protocols, where they combine Ghia centerlines and Botella–Peyret pressure profiles with wall root mean square error and discrete divergence for their continuum pathway tests.
Mira: That combination sounds like a very thorough check because it covers both the velocity field structure using centerlines and the pressure recovery using those specific profiles to measure errors.
Lev: And then they have a DSMC pathway that tests replicate spread, higher moments, and maximum pointwise differences for their rarefied flow evidence. So they’re checking different kinds of physical metrics depending on which simulation type you are looking at.
Kai: When we look at the model evaluation metrics, they use a coordinate multilayer perceptron or MLP that maps the Reynolds number and coordinates x and y to the velocity, vorticity, and pressure fields using a hyperbolic tangent activation function.
Mira: And then they combine that with something called POD deeponet which uses a fixed spatial basis combined with a coefficient branch to separate the representation error from the prediction error. That’s an interesting way to decompose where the model is failing.
Lev: If we were running this on real hardware, I'd worry about how fast that coordinate network inference is actually going, especially when you have all those different inputs and layers involved.
Kai: The paper shows a pretty strong inference advantage here; a three seed ensemble for the blind Reynolds number twenty seven five case attains relative L2 errors of one point four two three percent in velocity and four point two six four percent in pressure for that case.
Mira: So it’s not just about accuracy on the training data, but how quickly you can get a result when you have a new input, which is what they are emphasizing here.
Lev: A relative L2 error of one point four two three percent sounds good when compared to what we typically see in these kinds of physics-informed models, assuming the underlying assumptions hold true.
Kai: And the paper shows that this advantage is rapid parameter to field evaluation after offline training; a three seed sixty five by sixty five ensemble requires approximately zero point nine three milliseconds, whereas the reference CPU solution takes about eight seconds in their measured environment.
Mira: That inference to solver speed ratio of approximately eight point seven times ten cubed is quite substantial for this type of complex fluid dynamics problem. It shows that the reduced order script is very fast compared to solving the full equation from scratch every time you want a new field.
Lev: Eight point seven times ten cubed is a large number, but it’s important to remember that this speed ratio depends entirely on the hardware context and how well those fixed baselines were established.
Kai: They are also testing learned kinetic closures, which are models that solve local maps after they've been deployed into their time advancing solvers. The collision and Fokker-Planck networks handle these local maps.
Mira: That’s where the uncertainty gets tricky; the paper mentions that DSMC receives direct literature validation before neural collision transfer, which is a good way to anchor those kinetic models in established physics.
Lev: If we are talking about kinetic maps, we need to be really careful about how reliable that transfer is once you move it from a simulation environment to something meant for real-time inference.
Kai: They use relative discrete L2 norm epsilon two equals the predicted minus the reference squared divided by the reference squared, where q is the scalar field and i identifies one of N locations. That’s their metric for field error across all these different methods.
Mira: So they aren't just looking at a single error number; they are quantifying how that error varies across every single point in the computed field, which is much more informative than just an average.
Lev: Quantifying it at N locations means you’re dealing with N different local errors, and you have to make sure those local tests are robust enough to cover all the failure modes of the model.
Kai: The paper also shows that saved artifacts support regression testing through declared scalar tolerances, array shape checks, finite value checks and explicit wall condition assertions.
Mira: That’s good because it means you can set up automated gates during continuous integration to ensure that when someone updates the code or data, it doesn't accidentally violate those physical constraints.
Lev: I agree with that; having those explicit assertions helps catch subtle numerical instabilities early on before they become problems in a real deployment scenario.
Kai: So, looking at the whole picture of FlowMLLab, it’s about building a traceable path from numerical fluid mechanics to validated scientific machine learning.
Mira: It’s about emphasizing that evidence rather than just black box curve fitting, which is the core philosophy driving the whole framework.
Lev: And I think this framework contributes an experimental harness rather than proposing another neural architecture, which keeps it grounded in the physics we already understand well.
Kai: The implication for real hardware is that we need this kind of rigorous validation harness before we can trust any of these accelerated solvers when they move out of a research notebook and into a production environment.
Conclusion: Tom: So we're wrapping up on FlowMLLab, which is this open source framework for reproducible computational fluid dynamics and scientific machine learning experiments now that we've talked through all the details.
Kai: Basically, it’s this system that connects validated fluid mechanics solvers to scientific machine learning experiments under a very strict contract governing everything from data qualification to case wise partitions.
Mira: It really boils down to emphasizing physical evidence over just black box curve fitting, which is the core philosophy driving the whole framework.
Lev: And I think this framework contributes an experimental harness rather than proposing another neural architecture, which keeps it grounded in the physics we already understand well.
Kai: The implication for real hardware is that we need this kind of rigorous validation harness before we can trust any of these accelerated solvers when they move out of a research notebook and into a production environment.
Mira: It’s about making sure the physical evidence is what drives the model selection process rather than just minimizing some abstract loss function.
Lev: I think if this framework can reliably connect solvers to their benchmark data with such transparency, it could really help us move those accelerated models toward real-world deployment faster.
Kai: We see a lot of potential here for making sure that the machine learning part actually provides something useful beyond just achieving a low training loss number.
Mira: It gives us a path to trust these surrogate checks because every claim is tied to reusable code, an immutable record, and specific physical validation targets.
Lev: Yeah, and the continuous integration checks on different Python versions mean it’s built to handle the complexity of real-world software environments without breaking.
Kai: We'll keep looking at how this framework handles those multi parameter continuum families in future work because that’s where it could get really interesting for broader applications.
Mira: And we'll definitely want to see how they handle uncertainty calibration and explicit out of distribution detection before those broader operators can be assessed reliably.
Lev: Plus, adding more kinetic benchmarks spanning several Knudsen and Mach numbers will be necessary to ensure the sampling uncertainty is properly propagated into every model comparison. This paper provides a reproducible path from numerical fluid mechanics to validated scientific machine learning under a contract governing solver output, data qualification, case wise partitions and baselines.
More episodes
- 2611.14082-Two atoms with strong light-induced dipolar interactions
- 2611.14040-Characterization of BNLs 20 and 30 micrometer thick LGADs for the Electron Ion Collider
- 2611.13399-Lift-element-based dynamic network of vortex gust-airfoil interactions
- 2611.13476-Hopfion Superlattices in 3D Twisted Moir'e Light Fields
- 2611.13642-Investigation of the timing performance of double-sided p-type 3D silicon sensors produced by CNM
- 2611.13830-SiPM optical readout of a PICOSEC Micromegas precise timing detector
- 2611.14152-Where are the shortest-path nodes in spatial networks?
- 2611.14219-Sub-Ice: semi-automated mapping of basal channels from ice shelf surface elevation data
- 2611.16341-SUMNO: Spatially Unrolled Multigrid Neural Operator for Fluid Flow Surrogates
- 2611.16090-Multi-UTE Myelin Fraction Mapping: Repeatability and Cross-Field-Strength Reproducibility at 1.5T and 3T