FlowMLLab: An open-source framework for reproducible computational-fluid-dynamics and scientific-machine-learning experiments
Listen
Radio episode about this paper
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.
University of Massachusetts Amherst
physics.ed-ph
Submitted: 2026-08-24
Updated: 2026-11-17
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 92/100
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)…
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
Summary
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) pathway generates cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway supplies rarefied-flow evidence with sampling diagnostics Case-wise partitions prevent leakage, and matched non-neural baselines determine whether learning offers a measurable advantage By retaining numerical provenance, blind-case protocols and physical validation targets, FlowMLLab emphasizes traceable evidence rather than black-box curve fitting
Framework Architecture
The repository has five interacting layers that constitute the software architecture The installable flowmllab/ package handles discovery, asset checks, figure generation and quality assurance (QA), whereas common/ contains the CFD solver, pressure recovery, physical partitions and baselines The data/ and results/ directories separate reference evidence from predictions, while advanced/ isolates Fokker–Planck calculations from the core Sixteen notebooks expose these components as tutorials rather than independent implementations
Data and Reproducibility Contract
The cavity archive stores u, v, p, ψ and ω on a 65 × 65 grid for Reynolds numbers from 100 to 400 A quality table records solver acceptance, and a Secure Hash Algorithm 256-bit (SHA-256) digest detects substitution The splitting unit is a complete Reynolds-number field, so nodes from one case never cross subset boundaries Blind cases cannot influence scaling, architecture selection, POD rank or early stopping, and loss weights are fixed before blind evaluation CSV files preserve seeds and candidate architectures, JavaScript Object Notation (JSON) records models and metrics, and NumPy zipped archives (NPZ) store predictions
Validation Protocols
The continuum pathway combines Ghia centerlines and Botella–Peyret pressure profiles with wall root-mean-square (RMS) error and discrete divergence The continuum pathway combines centerlines and Botella–Peyret pressure profiles with wall root-mean-square (RMS) error and discrete divergence DSMC tests add replicate spread, higher moments and maximum pointwise differences All continuum field errors use the relative discrete L2 norm ϵ2(q) = [PN i=1 q pred i − q ref i 2 PN i=1 q ref i 2]1, where q is the evaluated scalar field, i identifies one of N locations, and superscripts pred and ref denote predicted and reference values
Model Evaluation Metrics
The coordinate multilayer perceptron (MLP) maps (Re, x, y) to (u, v, p) with a hyperbolic-tangent activation suited to the smooth cavity family POD–DeepONet combines a fixed spatial basis with a coefficient branch, separating representation error from coefficient-prediction error The collision and Fokker–Planck networks solve local maps that are evaluated after deployment in their time-advancing solvers All continuum field errors use the relative discrete L2 norm ϵ2(q) = [PN i=1 q pred i − q ref i 2 PN i=1 q ref i 2]1, where q is the evaluated scalar field, i identifies one of N locations, and superscripts pred and ref denote predicted and reference values
Inference Advantage
The coordinate-network validation shows that a three-seed ensemble attains relative L2 errors of 1.423% in velocity and 4. p. 6 Figure 2 presents the untouched Re = 275 case, for which the three-seed
ensemble attains relative L2 errors of 1. 423% in velocity and 4. Figure 3 shows that the prediction preserves the centerline fidelity of the
reference CFD solver, without claiming to improve the Ghia benchmark
itself. Its demonstrated advantage is rapid parameter-to-field evaluation
after offline training: a three-seed 65 × 65 ensemble requires approximately
0. Its demonstrated advantage is rapid parameter-to-field evaluation
after offline training: a three-seed 65 × 65 ensemble requires approximately
0. 93 ms, whereas the reference CPU solution requires 8. 0 s in the measured
environment. The resulting inference-to-solver speed ratio is approximately
8.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Scientific Scope and Limitations
The continuum archive is deliberately small and two-dimensional, being restricted to a square cavity in which only the Reynolds number varies The DSMC implementation likewise prioritizes inspectability through the HS–NTC collision sequence, diffuse walls and a declared post-sampling filter whose output is checked against published wall pressure The scalar Reynolds-number branch must therefore be interpreted as a restricted parametric operator rather than a broad multi-parameter model
Conclusion
FlowMLLab 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 Physical diagnostics and machine-readable evidence make surrogate checks available to users and continuous integration The continuum examples validate velocity and pressure before blind-field assessment, while POD–DeepONet demonstrates an inference advantage without overstating benchmark accuracy DSMC receives direct literature validation before neural collision transfer, and Fokker–Planck is tested in closed-loop operation Tutorials make these capabilities accessible, but each claim remains tied to reusable code, an immutable record, a matched baseline and a physical validation target The fixed archive holds coordinates, boundary conditions and blind cases constant Machine-readable records connect each plot to its model, prediction and timing The CLI checks the data contract in fast mode, whereas full mode verifies notebooks and hashes before tolerance-based comparison Continuous integration repeats these gates on three Python versions The evaluation never rests solely on a low training loss or visually overlapping centerlines Each experiment declares the cases available during selection and evaluates a matched non-neural baseline under the same conditions before freezing its choice rule Aggregate norms are then interpreted with local diagnostics: the continuum cavity requires near-wall velocity and pressure tests, particle calculations require replicate variation and higher moments, and closure models must remain stable in closed-loop operation Negative results remain visible because a neural model that is less accurate than interpolation must justify its use through exact constraint enforcement or amortized computational cost Every speed ratio therefore states the reference time and ensemble size together with the hardware context, and training cost is kept separate from inference cost The software deliberately separates compact reference solvers from researchgrade evidence Reference implementations remain small enough to inspect and modify on a CPU, whereas claims about learned collision or closure models are tied to published a-posteriori studies The software contributes an experimental harness rather than proposing another neural architecture Physical diagnostics expose failures that a global norm may hide, and closed-loop tests determine whether a kinetic map remains reliable after deployment Saved artifacts support regression testing through declared scalar tolerances, array-shape checks, finite-value checks and explicit wall-condition assertions Hashes detect dataset substitution, but stochastic calculations cannot be expected to remain bitwise identical across platforms FlowMLLab therefore stores seed-specific outputs and compares ensembles through declared statistical summaries, ensuring that normal DSMC sampling variation is not mistaken for a software defect The framework connects the solvers to their benchmark data, while case-wise partitions resist leakage and transparent baselines test whether learning adds practical value The tutorials consistently place physical evidence before model fitting The cavity tutorial produces Ghia velocity centerlines and validates recovered pressure against Botella–Peyret before pressure is admitted as a learning target The DSMC tutorial matches Re, Kn and Ma to the published condition, then compares wall pressure with Mohammadzadeh data before presenting neural fields Higher-order moments follow the primary variables, and every surrogate choice is frozen before blind Reynolds numbers are opened The framework 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 Its computational fluid dynamics (CFD) pathway generates cavity data
Software Functionalities
The principal functions are listed as follows
**: Cavity-field generation includes residual audits, Ghia centerlines and least-squares pressure recovery **
• Case-wise baselines accompany coordinate MLP models, while POD–DeepONet predicts coefficients for a fixed spatial basis
• Maxwellian sampling and particle-moment recovery introduce sampling analysis before the readable DSMC implementation
• Published continuum and DSMC data are compared through figures whose numerical norms are also stored in machine-readable form
• Extension interfaces support generalization studies, physics-guided losses, uncertainty analysis and learned closures
• Deterministic release checks combine dataset hashing with figure generation from saved evidence
Future Development
Future development will first address multi-parameter continuum families through geometry-aware representations and inputs that can express boundary functions or spatially varying conditions Uncertainty calibration and explicit out-of-distribution detection are also needed before those broader operators can be assessed reliably Additional kinetic benchmarks should span several Knudsen and Mach numbers, with sampling uncertainty propagated into every model comparison A future container image will reduce platform variation for the optional neural and closure environments
References
[1] Steven L. Brunton, Bernd R. Noack, and Petros Koumoutsakos. Machine learning for fluid mechanics [2] Karthik Duraisamy, Gianluca Iaccarino, and Heng Xiao. p. 0 FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. edu
Table 1: Code metadata (mandatory). Motivation and significance
Machine learning supports reduced-order modeling, closure construction,
flow reconstruction and solver acceleration [1, 2, 3]. FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. Global norms are paired with local tests because overlap can conceal measurable or corner-localized errors. The continuum pathway combines Ghia
5 [4], while the speed field and streamlines provide an independent
test of flow topology. Pressure is then evaluated at Re = 1000 on 652 and 1292
grids against Botella and Peyret [5], using the common gauge p(1/2, 1/2) = 0. A sparse least-squares system fits the edge gradients, and the
gauge p(1/2, 1/2) = 0 removes the arbitrary pressure constant. Pressure
becomes an admissible learning target only after this reconstruction has been
compared with the Botella–Peyret benchmark [5]. The continuum benchmark is a two-dimensional lid-driven cavity with side
length L and lid speed Ulid. Dimensional position and time are written
as (x
∗
, y∗
) and t
∗
, with nondimensional counterparts x = x
∗/L, y = y
∗/L
and t = t
∗Ulid/L. FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. By retaining numerical provenance, blind-case protocols and physical
validation targets, FlowMLLab emphasizes traceable evidence rather than
black-box curve fitting. Keywords: scientific machine learning, computational fluid dynamics,
reproducibility, neural operators, direct simulation Monte Carlo, validation
∗Corresponding author
Email address: roohie@umass. FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. Pressure is recovered after the velocity solution. Defining p = (p
∗ −
p
∗
ref )/(ρU2
lid) relative to the dimensional reference pressure p
∗
ref , the momentum equations provide
px = − (uux + vuy) + Re−1∇2u, (3)
py = − (uvx + vvy) + Re−1∇2
v, (4)
where subscripts denote partial differentiation, so that ux = ∂u/∂x and
py = ∂p/∂y. These rules allow new models to use identical
evidence. Data contract and reproducible execution
The cavity archive stores u, v, p, ψ and ω on a 65 × 65 grid for Reynolds
numbers {100, 150, 175, 200, 225, 250, 275, 300, 350, 375, 400}. By retaining numerical provenance, blind-case protocols and physical
validation targets, FlowMLLab emphasizes traceable evidence rather than
black-box curve fitting. Keywords: scientific machine learning, computational fluid dynamics,
reproducibility, neural operators, direct simulation Monte Carlo, validation
∗Corresponding author
Email address: roohie@umass. Case-wise partitions
prevent leakage, and matched non-neural baselines determine whether learning
offers a measurable advantage. Examples include a coordinate network and a
proper orthogonal decomposition (POD) deep operator network (DeepONet),
together with learned kinetic closures. edu
Table 1: Code metadata (mandatory). Motivation and significance
Machine learning supports reduced-order modeling, closure construction,
flow reconstruction and solver acceleration [1, 2, 3]. Keywords: scientific machine learning, computational fluid dynamics,
reproducibility, neural operators, direct simulation Monte Carlo, validation
∗Corresponding author
Email address: roohie@umass. edu (Ehsan Roohi)
arXiv:2609. FlowMLLab: An open-source framework for
reproducible computational-fluid-dynamics and
scientific-machine-learning experiments
Ehsan Roohia,∗
aDepartment of Mechanical and Industrial Engineering, University of Massachusetts
Amherst, 160 Governors Drive, Amherst, MA 01003, USA
Abstract
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) pathway generates
cavity data, whereas its direct simulation Monte Carlo (DSMC) pathway
supplies rarefied-flow evidence with sampling diagnostics. Case-wise partitions
prevent leakage, and matched non-neural baselines determine whether learning
offers a measurable advantage. Examples include a coordinate network and a
proper orthogonal decomposition (POD) deep operator network (DeepONet),
together with learned kinetic closures.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Proper evidence-based model selection ensures that
Case-wise partitions prevent leakage,
meaning new learning models are evaluated against fixed evidence under identical protocols to determine if theyoffer a measurable advantage.
-
The framework allows users to replace components, as it
retains numerical provenance,
enabling researchers to test whether a learned collision or closure model is reliable after deployment by tying claimsto published a-posteriori studies.
-
The system enables inference acceleration by demonstrating that the reduced-order script can achieve an
inference-to-solver speed ratio of approximately 8.7 x 103,
significantly faster than the reference CPU solution. -
The framework provides comprehensive diagnostics by combining aggregate errors with local tests, such as using
Ghia centerlines and Botella–Peyret pressure profiles with wall root-mean-square (RMS) error and discrete divergence
to expose failures that a global norm may hide. -
The kinetic pathway validates models through closed-loop operation, where the
Fokker–Planck MLP is called in every cell, evaluation measures closed-loop stability and end-to-end cost rather than offline accuracy alone.
Abstract
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.
Related papers
- Raytracing Black Holes with AI Accelerators
- Students' Validation Criteria for AI-Generated Physics Solutions
- Thermal fluctuations and electronic readout using a moving-coil movement
- Balancing broomsticks to a t!
- Predictive Modeling for High Impact Active Learning Classrooms
- A Reproducible Inertia Dynamometer for Vocational Schools: Design, Fabrication, and Pedagogy