Initial commit without model file

.gitattributes

@@ -0,0 +1 @@
+*.pth filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,22 @@
+FROM nvcr.io/nvidia/modulus/modulus:24.12
+
+# Install additional dependencies
+COPY requirements.txt /workspace/requirements.txt
+RUN pip install -r /workspace/requirements.txt
+
+# Copy application files
+COPY app.py /workspace/
+COPY conf /workspace/conf/
+COPY outputs/main/flow_network.0.pth /workspace/outputs/main/
+
+# Set working directory
+WORKDIR /workspace
+
+# Expose Streamlit port
+EXPOSE 8501
+
+# Set environment variable to disable CUDA
+ENV CUDA_VISIBLE_DEVICES=""
+
+# Command to run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.address", "0.0.0.0"] 

README.md

@@ -0,0 +1,35 @@
+# 3D Wind Flow Around Building Visualization
+
+This interactive application demonstrates computational fluid dynamics (CFD) simulation of wind flow around a parameterized building using deep learning. The model was trained using NVIDIA Modulus to solve the Navier-Stokes equations with turbulence modeling.
+
+## Features
+
+- **Real-time Visualization**: Instantly see how wind flows around buildings of different sizes and positions
+- **Interactive Parameters**:
+  - Building position (X, Y)
+  - Building dimensions (width, depth, height)
+- **Multiple Views**:
+  - Velocity magnitude at mid-height
+  - Pressure distribution
+  - 3D streamlines showing flow patterns
+
+## Technical Details
+
+- **Physics**: 3D steady-state Navier-Stokes with turbulence model
+- **Domain**: [0,10] x [0,5] x [0,5] meters
+- **Inlet Conditions**: 10 m/s uniform flow
+- **Model**: FourierNet trained using NVIDIA Modulus
+- **Hardware**: GPU-accelerated inference
+
+## How to Use
+
+1. Use the sliders in the sidebar to adjust building parameters
+2. The visualizations will update in real-time:
+   - Top left: Velocity magnitude contour
+   - Top right: Pressure distribution
+   - Bottom: 3D streamlines with building geometry
+3. You can rotate and zoom the 3D view using your mouse
+
+## About
+
+This demo showcases the application of deep learning to computational fluid dynamics, enabling real-time prediction of complex flow fields. The model was trained on parametric building geometries to understand flow patterns and pressure distributions around buildings of varying sizes and positions. 

app.py

@@ -0,0 +1,348 @@
+import streamlit as st
+import torch
+import numpy as np
+from omegaconf import OmegaConf
+from modulus.sym.hydra import instantiate_arch
+from modulus.sym.key import Key
+import plotly.graph_objects as go
+from pathlib import Path
+
+# Configure page and cache settings
+st.set_page_config(page_title="3D Wind Flow Visualization", layout="wide")
+st.title("Interactive 3D Wind Flow Around Building")
+
+# Load configuration
+@st.cache_resource
+def load_config():
+    cfg = OmegaConf.load('conf/config.yaml')
+    return cfg.arch.fourier_net
+
+# Initialize model
+@st.cache_resource
+def load_model():
+    # Create flow network
+    flow_net = instantiate_arch(
+        input_keys=[
+            Key("x"), Key("y"), Key("z"),
+            Key("bld_x"), Key("bld_y"),
+            Key("bld_width"), Key("bld_depth"), Key("bld_height"),
+        ],
+        output_keys=[Key("u"), Key("v"), Key("w"), Key("p")],
+        cfg=load_config(),
+    )
+    
+    # Load trained weights and ensure CPU mode
+    state_dict = torch.load('outputs/main/flow_network.0.pth', map_location=torch.device('cpu'))
+    flow_net.load_state_dict(state_dict)
+    flow_net.eval()  # Set to evaluation mode
+    return flow_net
+
+try:
+    model = load_model()
+except Exception as e:
+    st.error(f"Error loading model: {str(e)}")
+    st.stop()
+
+# Create sidebar with building parameters
+st.sidebar.header("Building Parameters")
+bld_x = st.sidebar.slider("Building X Position", 2.0, 6.0, 4.0, 0.1)
+bld_y = st.sidebar.slider("Building Y Position", 1.0, 4.0, 2.5, 0.1)
+bld_width = st.sidebar.slider("Building Width", 0.5, 2.0, 1.0, 0.1)
+bld_depth = st.sidebar.slider("Building Depth", 0.5, 1.5, 1.0, 0.1)
+bld_height = st.sidebar.slider("Building Height", 1.0, 2.5, 1.5, 0.1)
+
+# Create grid for visualization (reduced resolution for CPU)
+@st.cache_data
+def create_grid():
+    x = np.linspace(0, 10, 30)  # Reduced from 50
+    y = np.linspace(0, 5, 15)   # Reduced from 25
+    z = np.linspace(0, 5, 15)   # Reduced from 25
+    return np.meshgrid(x, y, z, indexing='ij')
+
+X, Y, Z = create_grid()
+
+# Batch processing for CPU efficiency
+def predict_flow(x, y, z, bld_params, batch_size=5000):
+    try:
+        # Prepare input grid
+        xyz = torch.tensor(np.stack([x.flatten(), y.flatten(), z.flatten()], axis=1), dtype=torch.float32)
+        num_points = len(xyz)
+        
+        # Initialize output arrays
+        u_out = np.zeros(num_points)
+        v_out = np.zeros(num_points)
+        w_out = np.zeros(num_points)
+        p_out = np.zeros(num_points)
+        
+        # Process in batches
+        for i in range(0, num_points, batch_size):
+            batch_end = min(i + batch_size, num_points)
+            batch_xyz = xyz[i:batch_end]
+            
+            # Create input dictionary for batch
+            inputs = {
+                "x": batch_xyz[:, 0:1],
+                "y": batch_xyz[:, 1:2],
+                "z": batch_xyz[:, 2:3],
+                "bld_x": torch.full((batch_end-i, 1), bld_params[0], dtype=torch.float32),
+                "bld_y": torch.full((batch_end-i, 1), bld_params[1], dtype=torch.float32),
+                "bld_width": torch.full((batch_end-i, 1), bld_params[2], dtype=torch.float32),
+                "bld_depth": torch.full((batch_end-i, 1), bld_params[3], dtype=torch.float32),
+                "bld_height": torch.full((batch_end-i, 1), bld_params[4], dtype=torch.float32)
+            }
+            
+            # Make prediction
+            with torch.no_grad():
+                outputs = model(inputs)
+            
+            # Store batch results
+            u_out[i:batch_end] = outputs["u"].numpy().flatten()
+            v_out[i:batch_end] = outputs["v"].numpy().flatten()
+            w_out[i:batch_end] = outputs["w"].numpy().flatten()
+            p_out[i:batch_end] = outputs["p"].numpy().flatten()
+        
+        # Reshape outputs
+        u = u_out.reshape(x.shape)
+        v = v_out.reshape(x.shape)
+        w = w_out.reshape(x.shape)
+        p = p_out.reshape(x.shape)
+        
+        return u, v, w, p
+    except Exception as e:
+        st.error(f"Error in prediction: {str(e)}")
+        return None, None, None, None
+
+# Add a progress indicator
+progress_text = st.empty()
+progress_text.text("Computing flow field...")
+
+# Make prediction
+bld_params = np.array([bld_x, bld_y, bld_width, bld_depth, bld_height])
+u, v, w, p = predict_flow(X, Y, Z, bld_params)
+
+if u is None:
+    st.error("Failed to make prediction. Please check the model and parameters.")
+    st.stop()
+
+progress_text.text("Visualization ready!")
+
+# Create visualization
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Velocity Magnitude (Slice at Z=2.5m)")
+    z_slice_idx = len(Z[0,0]) // 2
+    
+    vel_mag = np.sqrt(u[:,:,z_slice_idx]**2 + v[:,:,z_slice_idx]**2 + w[:,:,z_slice_idx]**2)
+    
+    # Create building rectangle for the plot
+    building_x = [bld_x, bld_x + bld_width, bld_x + bld_width, bld_x, bld_x]
+    building_y = [bld_y, bld_y, bld_y + bld_depth, bld_y + bld_depth, bld_y]
+    
+    fig = go.Figure()
+    
+    # Add velocity magnitude contour
+    fig.add_trace(go.Contour(
+        x=X[:,0,0],
+        y=Y[0,:,0],
+        z=vel_mag.T,
+        colorscale='Viridis',
+        colorbar=dict(title='Velocity (m/s)'),
+    ))
+    
+    # Add building outline
+    fig.add_trace(go.Scatter(
+        x=building_x,
+        y=building_y,
+        mode='lines',
+        line=dict(color='red', width=2),
+        name='Building'
+    ))
+    
+    fig.update_layout(
+        xaxis_title="X (m)",
+        yaxis_title="Y (m)",
+        width=600,
+        height=400
+    )
+    
+    st.plotly_chart(fig)
+
+with col2:
+    st.subheader("Pressure Distribution (Slice at Z=2.5m)")
+    
+    fig = go.Figure()
+    
+    # Add pressure contour
+    fig.add_trace(go.Contour(
+        x=X[:,0,0],
+        y=Y[0,:,0],
+        z=p[:,:,z_slice_idx].T,
+        colorscale='RdBu',
+        colorbar=dict(title='Pressure'),
+    ))
+    
+    # Add building outline
+    fig.add_trace(go.Scatter(
+        x=building_x,
+        y=building_y,
+        mode='lines',
+        line=dict(color='red', width=2),
+        name='Building'
+    ))
+    
+    fig.update_layout(
+        xaxis_title="X (m)",
+        yaxis_title="Y (m)",
+        width=600,
+        height=400
+    )
+    
+    st.plotly_chart(fig)
+
+# Add streamlines visualization
+st.subheader("3D Streamlines")
+
+# Downsample for streamlines
+skip = 3
+X_sub = X[::skip,::skip,::skip]
+Y_sub = Y[::skip,::skip,::skip]
+Z_sub = Z[::skip,::skip,::skip]
+u_sub = u[::skip,::skip,::skip]
+v_sub = v[::skip,::skip,::skip]
+w_sub = w[::skip,::skip,::skip]
+
+# Function to interpolate velocity at any point
+def interpolate_velocity(x, y, z):
+    # Find indices
+    ix = np.clip(int((x / 10.0) * (len(X)-1)), 0, len(X)-2)
+    iy = np.clip(int((y / 5.0) * (len(Y[0])-1)), 0, len(Y[0])-2)
+    iz = np.clip(int((z / 5.0) * (len(Z[0,0])-1)), 0, len(Z[0,0])-2)
+    
+    return u[ix,iy,iz], v[ix,iy,iz], w[ix,iy,iz]
+
+# Function to compute streamline
+def compute_streamline(x_start, y_start, z_start, num_steps=50, dt=0.1):
+    streamline_x = [x_start]
+    streamline_y = [y_start]
+    streamline_z = [z_start]
+    
+    x, y, z = x_start, y_start, z_start
+    
+    for _ in range(num_steps):
+        # Get velocity at current point
+        u_val, v_val, w_val = interpolate_velocity(x, y, z)
+        
+        # Update position using RK4
+        x_new = x + u_val * dt
+        y_new = y + v_val * dt
+        z_new = z + w_val * dt
+        
+        # Check if point is inside domain and outside building
+        if (0 <= x_new <= 10 and 0 <= y_new <= 5 and 0 <= z_new <= 5 and
+            not (bld_x <= x_new <= bld_x + bld_width and 
+                 bld_y <= y_new <= bld_y + bld_depth and 
+                 0 <= z_new <= bld_height)):
+            streamline_x.append(x_new)
+            streamline_y.append(y_new)
+            streamline_z.append(z_new)
+            x, y, z = x_new, y_new, z_new
+        else:
+            break
+    
+    return streamline_x, streamline_y, streamline_z
+
+# Create streamlines using plotly
+fig = go.Figure()
+
+# Add streamlines from inlet
+num_streamlines = 20
+y_starts = np.linspace(0.5, 4.5, num_streamlines)
+z_starts = np.linspace(0.5, 4.5, num_streamlines)
+
+# Add streamlines from different starting positions
+for y_start in y_starts[::2]:  # Skip some to reduce density
+    for z_start in z_starts[::2]:  # Skip some to reduce density
+        # Skip if starting point would be inside building
+        if (bld_x <= 0 <= bld_x + bld_width and 
+            bld_y <= y_start <= bld_y + bld_depth and 
+            0 <= z_start <= bld_height):
+            continue
+            
+        x_start = 0.1  # Start slightly inside domain
+        streamline_x, streamline_y, streamline_z = compute_streamline(x_start, y_start, z_start)
+        
+        # Color based on velocity magnitude
+        velocities = []
+        for i in range(len(streamline_x)):
+            u_val, v_val, w_val = interpolate_velocity(streamline_x[i], streamline_y[i], streamline_z[i])
+            velocities.append(np.sqrt(u_val**2 + v_val**2 + w_val**2))
+        
+        # Create streamline
+        fig.add_trace(go.Scatter3d(
+            x=streamline_x,
+            y=streamline_y,
+            z=streamline_z,
+            mode='lines',
+            line=dict(
+                color=velocities,
+                colorscale='Viridis',
+                width=3
+            ),
+            showlegend=False
+        ))
+
+# Add building
+building_vertices = [
+    [bld_x, bld_y, 0],                          # 0: front bottom left
+    [bld_x + bld_width, bld_y, 0],              # 1: front bottom right
+    [bld_x + bld_width, bld_y + bld_depth, 0],  # 2: back bottom right
+    [bld_x, bld_y + bld_depth, 0],              # 3: back bottom left
+    [bld_x, bld_y, bld_height],                 # 4: front top left
+    [bld_x + bld_width, bld_y, bld_height],     # 5: front top right
+    [bld_x + bld_width, bld_y + bld_depth, bld_height],  # 6: back top right
+    [bld_x, bld_y + bld_depth, bld_height]      # 7: back top left
+]
+
+# Define faces using indices
+i = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4]  # First vertex of each triangle
+j = [1, 2, 4, 1, 5, 2, 6, 3, 7, 2, 5, 7]  # Second vertex of each triangle
+k = [2, 3, 5, 4, 6, 6, 7, 7, 6, 6, 6, 6]  # Third vertex of each triangle
+
+fig.add_trace(go.Mesh3d(
+    x=[v[0] for v in building_vertices],
+    y=[v[1] for v in building_vertices],
+    z=[v[2] for v in building_vertices],
+    i=i,
+    j=j,
+    k=k,
+    color='red',
+    opacity=0.5,
+    name='Building'
+))
+
+fig.update_layout(
+    scene=dict(
+        xaxis_title="X (m)",
+        yaxis_title="Y (m)",
+        zaxis_title="Z (m)",
+        aspectmode='data',
+        camera=dict(
+            up=dict(x=0, y=0, z=1),
+            center=dict(x=0, y=0, z=0),
+            eye=dict(x=1.5, y=1.5, z=1.5)
+        )
+    ),
+    width=1200,
+    height=600
+)
+
+st.plotly_chart(fig)
+
+st.sidebar.markdown("""
+### Instructions
+1. Use the sliders to adjust building parameters
+2. The top plots show velocity and pressure at mid-height
+3. The bottom plot shows 3D streamlines around the building
+4. Red box represents the building
+""") 

conf/arch/fourier_net.yaml

@@ -0,0 +1,8 @@
+fourier_net:
+  arch_type: fourier
+  input_key_dims: [3, 5]       # (x, y, z) + 5 building parameters
+  output_key_dims: [3, 1]      # (u, v, w) + p
+  layer_size: 512
+  num_layers: 6
+  activation_fn: silu
+  weight_norm: true

conf/config.yaml

@@ -0,0 +1,82 @@
+defaults:
+  - modulus_default
+  - arch:
+      - fourier_net
+  - optimizer: adam
+  - scheduler: tf_exponential_lr
+  - loss: sum
+  - _self_
+
+jit: false
+save_filetypes: "vtk"
+
+custom:
+  parameterized: true
+  turbulent: true
+
+################################################################################
+# ARCHITECTURE
+################################################################################
+arch:
+  fourier_net:
+    arch_type: "fourier"
+    _target_: "modulus.sym.models.fourier_net.FourierNetArch"
+
+    # Input/Output dims
+    input_key_dims: [3, 5]        # (x,y,z) + (bld_x,bld_y,bld_width,bld_depth,bld_height)
+    output_key_dims: [3, 1]       # (u,v,w) + p
+
+    layer_size: 256
+    num_layers: 4
+    activation_fn: silu
+    weight_norm: true
+    adaptive_activations: false
+
+################################################################################
+# OPTIMIZER
+################################################################################
+optimizer:
+  lr: 0.001
+  betas: [0.9, 0.999]
+  eps: 1.0e-8
+  weight_decay: 1.0e-5
+
+################################################################################
+# SCHEDULER
+################################################################################
+scheduler:
+  decay_rate: 0.98
+  decay_steps: 1000
+
+################################################################################
+# LOSS
+################################################################################
+loss:
+  weights:
+    inlet: 20.0              # Strongly enforce inlet conditions
+    outlet: 5.0              # Increased to better maintain outflow
+    no_slip_building: 5.0    # Keep building interaction
+    top: 0.5                 # Further reduced wall influence
+    ground: 0.5              # Further reduced wall influence
+    sides_y0: 0.5            # Further reduced wall influence
+    sides_y5: 0.5            # Further reduced wall influence
+    interior: 10.0           # Strongly enforce momentum equations in interior
+
+################################################################################
+# TRAINING
+################################################################################
+training:
+  max_steps: 40000
+  rec_results_freq: 100
+  rec_constraint_freq: 5000
+  save_network_freq: 5000
+
+################################################################################
+# BATCH SIZES
+################################################################################
+batch_size:
+  inlet: 1024
+  outlet: 1024
+  no_slip_building: 2048
+  slip: 1024
+  interior: 4096

requirements.txt

@@ -0,0 +1,3 @@
+streamlit==1.24.0
+plotly==5.15.0
+pyvista==0.39.1