Physics-Nemo [Modulus ] : Advanced Topics

Explore inverse physics-informed neural networks, which infer viscosity from Burgers equation data using physics-based and data-driven losses, enabling CFD insights and pressure predictions from pivx velocity fields.

Extract the thermal diffusivity and kinematic viscosity by applying data-driven calibration to the advection–diffusion and Navier–Stokes equations, using the relative temperature c and its spatial derivatives.

Utilize the provided CSV dataset for a 2d channel flow with higher-temperature fins to compute diffusivity and kinematic viscosity, using temperature, velocity components, pressure, and coordinates from 13,000 data points.

Define the NVIDIA Modulus config file by creating config.yml with defaults, architecture, Adam optimizer, and TensorFlow exponential decay with 0.95 every 1000 steps, up to 100,000 steps.

Import and configure the needed libraries, define the configuration and main files, and set up the Navier-Stokes problem with domain geometry, constraints, and monitors in Modulus.

Point the modulus run to the config.yaml in the current directory, declare viscosity and diffusivity as symbols, and link them to the Navier-Stokes and advection-diffusion equations for a two-dimensional flow.

Define the flow, heat, invert, and diffusion nets to predict velocity, pressure, and temperature from x and y, then connect them with nodes to solve Navier–Stokes and advection.

Map csv data to x, y, u, v, p, c and temperature, transform open form data, and define continuity, momentum, and advection–diffusion constraints for an inverse neural network.

Add an inverse value monitor to track diffusion diffusivity and viscosity in the advection-diffusion and Navier-Stokes equations, averaging neural-network predicted values over 1000 steps.

Configure and run a Python solve for a heat sink project, fix configuration, syntax, and case errors, and monitor a long-running matrix and metrics output.

View and export results from inverse problems in Paraview, inspect constraints, and monitor convergence of viscosity and diffusivity across about 60,000 steps, with final values around 0.00986 and 0.00251.

Explore data-driven deep neural operators for simulating systems by mapping input functions to outputs without explicit equations, using DeepONet's branch and trunk networks to predict solutions at (x, t).

Define the problem of inverse derivative (integration) using a deep neural operator. Build a branch for full curve and a trunk for the target point to predict the integrated value.

Load numpy data in a Jupyter notebook, preparing train and test sets for deep neural operator; use trunk and branch design to model inverse and differentiation (integration) of the curve.

Define the configuration file for a deep neural operator in NVIDIA Modulus, detailing architecture, four-layer trunk and branch networks, and Adam optimizer settings.

Create a Python file and import libraries, including torch, NumPy, and Modulus, then configure a deep net with a fully connected architecture and set up the domain and grid data.

Define the run method and modulus config to build a trunk and branch deep neural network. Set inputs and outputs, create nodes, and load data for NVIDIA Modulus.

Load the data by locating a file path, using numpy.load with an absolute path and pickle enabled, then assign x_train, u_train, a_train and x_test, u_test, a_test for model training.

Add a deep or net data constraint to fit the network to the data, specifying in and out variables, batch size, and adding the constraint to the domain before solving.

Add a results validator to NVIDIA Modulus by using test data to compare graph outputs with inverse integration and differentiation, using sliced data of 100 points and multiple validator files.

Load the output file, extract true and predicted u values, and plot them to compare performance. The network learns the integration operator, producing results aligned with the true u.

Explore how Fourier neural operator trains on data to solve physics governing equations from initial conditions to future states, using Fourier transforms to learn from frequency domains.

Apply the Fourier neural operator to solve the Darcy flow problem in a porous medium, mapping permeability k and driving force f to the pressure u using Nvidia models.

Define the NVIDIA modulus configuration file for a 2D Fourier neural operator, including defaults, decoder and architecture, and training parameters like optimizer, loss, learning-rate schedule, and batch size.

Import needed libraries from modulus to configure the neural operator workflow, include solver and domain constraints, and use grid validator and plotter to handle and visualize data.

Define the data by loading, normalizing inputs, configuring paths, and splitting into training and testing sets to prepare neural networks for modeling.

Apply a supervised grid constraint to the domain using grid data and the network as nodes, configure patch and batch sizes, and add a validator to plot results.

Add a validator to compare predicted test data with results using a grid validator and a plotter. Configure the domain with validator data and solve with the CFG.

Execute the solver by preparing data and the utilities file, download the Nvidia data from Google Drive, run Python 3, and compare results with the neural operator and test data.

Examine the results view in NVIDIA Modulus: advanced topics, showing datasets, constraints, validators, and testing data, and how true and predicted outputs converge with extended neural network training.

solve a three-dimensional structural problem by applying a surface distributed load on a fixed bracket, analyzing tensile, compression, and shear stresses via the Navier equation with Lamé parameters.

define the Nvidia modulus config for a fully connected model with an exponential scheduler, adam optimizer, and loss, including surface boundary conditions and interior points for a 3d bracket analysis.

Create the main Python file, remove unused text files, and import key modulus components, geometry primitives, and constraints to build and run the model with a defined network architecture.

Define two neural networks, a displacement network and a stress network, that take x, y, z as input and predict displacement and six stress components in a fully connected architecture.

Define the geometry by setting up x, y, z variables and constructing a support, bracket, and fillet using specified origins, dimensions, and auxiliary regions.

Define the geometry for a 3d pen component by modeling a box, bracket, auxiliary parts, and a cylinder with a hole; rotate and translate around the x-axis, and apply fillets.

Declare boundary and interior constraints for a bracket geometry in NVIDIA Modulus, set domain bounds and back boundary conditions, apply front traction, and enforce interior equilibrium via pointwise constraints.

Configure the solver with domain, geometry (3d box and cylinder), and boundaries, instantiate models, and run a Python workflow to solve and plot displacement outputs.

Export results to CSV and load them for 3D visualization of bracket and interior support. Plot in Jupyter with pandas and matplotlib to visualize deformation and tensile stresses.

Solve a 3d flow with a multi-domain setup and non-slip boundaries, then compute heat transfer and diffusion through the fluid and solid heat sink using Nvidia modulus.

Configure the flow with config_flow.yaml and a parameterized, turbulence-enabled setup, then train the model using Adam optimizer and exponential learning, while preparing a separate thermal configuration file for heat diffusion.

Define geometry in a separate python flow using a class, with imports and fixed parameters for heatsink fins, origin coordinates, and a high‑resolution flow box to build the 3d model.

Define the geometry by coding a parameterized class, build the channel, heatsink base, and three fins, then derive the fluid geometry by subtraction.

Define the flow domain with a flow box and derive low- and high-resolution geometries from bounds. Set inlet and outlet geometries with a moving, parametrized plane along the channel.

Set up a flow simulation with NVIDIA Modulus by creating flo.py, importing required libraries, and configuring diffusion and advection-diffusion equations for a three-fin geometry.

Define the governing Navier-Stokes flow equation, with optional turbulence, and build a 3D fully connected neural network to predict velocity components v and w and pressure from x, y, z.

Define geometry and declare boundary constraints for a CFD flow. Configure inlet velocity profile, outlet zero pressure, non-slip walls, and interior low/high resolution with signed distance function based integral constraints.

Add a pressure monitor to the flow domain to measure inlet pressure at a fixed parameterization boundary with 1024 points and compute the mean pressure with torch.mean.

Follow a two-step workflow: run the flow first, then write the thermal configuration to train a model predicting temperature distribution and diffusion from fluid flow with a fully connected network.

Create a thermal config file for a three-fin flow by writing a Python script and importing Modulus libraries for domain, diffusion models, and geometry.

Define the governing equations for thermal advection-diffusion with diffusion interface using DNNs, configure modulus, and build main file, flow and thermal networks for inference.

Define and apply thermal boundary conditions and interior constraints in a multi-region domain, including inlet and outlet conditions, wall and interface criteria, heat source distribution, and diffusion and advection equations.

Execute flow and thermal computations by running python scripts, debugging imports and configurations, and validating parameterization, geometry, and Navier–Stokes components for the Modulus workflow.

Run thermal code in Modulus by loading the fin network and boundary nodes, fix syntax errors, fix theta settings, enable the Adam optimizer, and solve with the solver.

Review results from three-fin flow and three-fin thermal simulations, compare low and high resolution interiors, monitor pressure and convergence, and visualize coupled fluid and thermal data in Paraview.

Update the simulation by building a network that treats x, y, z as 3D inputs and predicts heat exchanger flow, with parameters defining and changing the geometry.

Update the threefin geometry to use parameter ranges instead of fixed values, defining height, length, and thickness for middle and side fins and passing these ranges in the code.

Update the flow network by adding design dimensions to the neural network inputs (x y z and fin dimensions), enabling geometry changes and optimization by pressure loss or maximum temperature.

update the thermal domain by configuring input keys as before, not limited to x, y, z, and paste them from the flow.

Run the retraining workflow for flow and thermal networks using range-based geometry inputs. Map input keys to flow net outputs u, v, w, p, and train for millions of steps.

explore how NVIDIA Modulus builds neural networks across varied geometries to compute flow and heat exchange results, enabling fast on-the-fly inference for aerospace design.