Archive CFD workflow 2026-10-12: _seiler_ref (part 2)

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/cmd/trellis/0_trellis_gen.sh

@@ -0,0 +1,2 @@
+# cd physiopt_new
+python scripts/sample_trellis.py --image input/0001.png --out_folder output/trellis_gen/0001

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/cmd/trellis/1_give_force.sh

@@ -0,0 +1,2 @@
+# cd physiopt_new
+python scripts/force_web_ui.py --out output/trellis_gen/0001/force_config.json --share --z_up

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/cmd/trellis/2_trellis_ours_opt.sh

@@ -0,0 +1,2 @@
+# cd physiopt_new
+python scripts/viewer_trellis_web_alternate.py --input output/trellis_gen/0001/slat_00.pt --force_config output/trellis_gen/0001/force_config.json --use_physics --res 64 --lr 0.001 --outer_cycles 20 --phys_steps_per_cycle 10 --sds_timestep 0.5 --lagrange_max 10.0 --guidance_scale 3.0 --sds_weight_start 0 --sds_weight_end 0 --sds_use_uncond --sds_target_z0_ema_beta 0.0 --compliance_threshold_ratio 0.1 --youngs_modulus_scale 1.0 --projection_mode inpaint --inpaint_dilate_rings 1 --inpaint_change_threshold 0.1 --inpaint_cfg_strength 5.0 --inpaint_t_start 0.4 --out_folder output/trellis_gen/0001/realforce_alternate --input_coord_system trellis_z_up

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/cmd/trellis/3_trellis_physiopt.sh

@@ -0,0 +1,2 @@
+# cd physiopt_new
+python scripts/viewer_trellis_web_physiopt.py --input output/trellis_gen/0001/slat_00.pt --force_config output/trellis_gen/0001/force_config.json --share --out_folder output/trellis_gen/0001/realforce_physiopt

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/src/drivernet.py

@@ -0,0 +1,232 @@
+"""
+Module for DrivAerNet++ related utilities.
+
+See https://github.com/Mohamedelrefaie/DrivAerNet
+"""
+
+import numpy as np
+import trimesh
+
+MESHRAWDIR = "/mnt/cvlab/scratch/cvlab/home/hantzhan/code_jk/fk-doob-physgen/code/data/drivaernet_plus/meshes/3DMeshesSTL/"
+ANNOTDIR = "/scratch/cvlab/datasets/datasets_/drivaernet/Annotations/"
+PRESSUREDIR = "/mnt/cvlab/scratch/cvlab/home/hantzhan/code_jk/fk-doob-physgen/code/data/drivaernet_plus/pressure/PressureVTK/"
+
+# Normalization from DrivAerNet++ space to [-0.9, 0.9]^3 cube
+# with x' = s * (R @ x + T)
+T = np.array([(4.1 - 1.05) / 2, 
+              -0.7, 
+              0.0])
+R = np.array([[-1, 0, 0], 
+              [ 0, 0, 1], 
+              [ 0, 1, 0]])
+S = 2 * 0.9 / (4.1 + 1.05)
+
+BACK_ANNOTS = {  # name of the annotation parts corresponding to the back of the car
+    "E": ["body_2", "windows_1", "body_roof", "body_tail_1"],
+    "F": ["body_1", "windows_1", "body_roof_1", "body_tail_1"],
+    "N": ["body_2", "windows_1", "body_roof_1", "body_tail_1"],
+}
+
+
+def load_clean(path):
+    """
+    Load a DrivAerNet++ mesh and clean it (normalization + face reorientation).
+    """
+    mesh = trimesh.load(path)
+    mesh = normalize_drivaernet(mesh)
+    mesh = reorient(mesh, drivaernet_world=False)
+    return mesh
+
+def load_clean_bodyback(mesh_path, annot_path, back_type, return_mesh=False):
+    """
+    Load a DrivAerNet++ example by parts (body / back separation) and normalize it.
+
+    Args:
+        mesh_path: path to the DrivAerNet++ mesh file.
+        annot_path: path to the DrivAerNet++ annotation file.
+        back_type: car type, one of "E", "F", or "N". (or the full instance name)
+        return_mesh: whether to also return the full mesh.
+    """
+    mesh = trimesh.load(mesh_path)
+    annot = trimesh.load(annot_path)
+    parts_fit = fit_annot_to_mesh(annot.geometry, mesh)
+    # Normalize / clean the meshes into our world space
+    mesh = reorient(normalize_drivaernet(mesh), drivaernet_world=False)
+    parts_fit = {k: normalize_drivaernet(p) for k, p in parts_fit.items()}
+    # Separate body and back
+    body, back = split_body_back(back_type, parts_fit, drivaernet_world=False)
+    wheels = split_body_wheels(mesh, drivaernet_world=False)[1:]
+    parts = [body, back] + wheels
+    if return_mesh:
+        return parts, mesh
+    else:
+        return parts
+
+
+# Normalization
+###############
+
+_R_transform = np.concatenate([R, np.zeros((3, 1))], axis=1)
+_R_transform = np.concatenate([_R_transform, np.array([[0, 0, 0, 1]])], axis=0)
+def normalize_drivaernet(mesh):
+    """Normalize mesh/points from DrivAerNet++ space to [-0.9, 0.9]^3 cube.
+
+    Args:
+        mesh: a trimesh object or a (N, 3) array of points.
+
+    Returns:
+        Normalized trimesh object or points.
+    """
+    if isinstance(mesh, trimesh.Trimesh):
+        mesh = mesh.copy()
+        mesh.apply_transform(_R_transform)
+        mesh.apply_translation(T)
+        mesh.apply_scale(S)
+        return mesh
+    else:  # assume it's a (N, 3) array of points
+        points = mesh @ R.T
+        points = points + T
+        points = points * S
+        return points
+
+def denormalize_drivaernet(mesh):
+    """Denormalize mesh/points from [-0.9, 0.9]^3 cube to DrivAerNet++ space.
+
+    Args:
+        mesh: a trimesh object or a (N, 3) array of points.
+    
+    Returns:
+        Denormalized trimesh object or points.
+    """
+    if isinstance(mesh, trimesh.Trimesh):
+        mesh.apply_scale(1 / S)
+        mesh.apply_translation(-T)
+        mesh.apply_transform(_R_transform.T)
+        return mesh
+    else:  # assume it's a (N, 3) array of points
+        points = mesh / S
+        points = points - T
+        points = points @ R
+        return points
+
+def fit_annot_to_mesh(annot, mesh):
+    """Rescale and translate annotation mesh to fit the DrivAerNet++ mesh.
+    Must be in the original DrivAerNet++ space!
+
+    Args:
+        annot: dict of trimesh objects of annotation.
+        mesh: a trimesh object of DrivAerNet++.
+    
+    Returns:
+        Rescaled and translated annotation mesh.
+    """
+    # Annotations are the half body without wheels
+    body = split_body_wheels(mesh)[0]
+    # Rescale the annotations from mm to m
+    annot = {k: a.copy().apply_scale(1e-3) for k, a in annot.items()}
+    # Rescale like the (half-)body
+    scale = body.extents / trimesh.util.concatenate(annot.values()).extents
+    scale[1] /= 2  # annots are only half a car along the y-axis
+    annot = {k: a.apply_scale(scale) for k, a in annot.items()}
+    # Translate to the body center
+    translation = body.bounds.mean(0) - trimesh.util.concatenate(annot.values()).bounds.mean(0)
+    translation[1] = 0 - trimesh.util.concatenate(annot.values()).bounds[1, 1]  # annots are only half a car
+    annot = {k: a.apply_translation(translation) for k, a in annot.items()}
+    return annot
+    
+
+# Face orientation
+##################
+
+def reorient(mesh, drivaernet_world=True):
+    """
+    Reorient faces of DrivAerNet++ mesh to have outward normals.
+    Only the left wheels are correctly oriented in the original meshes.
+    NOTE: the F_D instances (from DrivAerNet) are already correctly oriented.
+          However, as they don't have parts, we are not considering them here.
+    """
+    parts = split_body_wheels(mesh, drivaernet_world=drivaernet_world)
+    parts = reorient_parts(parts)
+    return trimesh.util.concatenate(parts)
+
+def reorient_parts(parts):
+    """
+    Reorient faces of DrivAerNet++ mesh parts to have outward normals.
+    Only the left wheels are correctly oriented in the original meshes.
+    """
+    for i, part in enumerate(parts):
+        if i in [1, 3]:  # left wheels
+            continue
+        part.invert()
+    return parts
+
+
+# Mesh parts
+############
+
+def split_body_wheels(mesh, drivaernet_world=True):
+    """
+    Split DrivAerNet++ mesh into body and wheels parts.
+    Wheel order: FL, FR, RL, RR.
+
+    Args:
+        mesh: a trimesh object of DrivAerNet++.
+        drivaernet_world: whether the mesh is in DrivAerNet++ world space,
+            or normalized space.
+    
+    Returns:
+        list of 5 meshes.
+    """
+    parts = mesh.split()
+    assert len(parts) == 5, "Expected 5 parts (body + 4 wheels)."
+
+    # Identify the body as the largest part (bbox-wise)
+    body_idx = np.argmax([np.prod(p.extents) for p in parts])
+    body = parts[body_idx]
+    wheels = [parts[i] for i in range(5) if i != body_idx]
+
+    # Sort wheels by position (x, y) for drivaernet world, (-x, z) otherwise
+    # Front then rear wheels
+    wheels.sort(key=lambda w: w.bounds.mean(0)[0], 
+                reverse=not drivaernet_world)
+    # Left then right wheels in each axle
+    ax = 1 if drivaernet_world else 2
+    if wheels[0].bounds.mean(0)[ax] > wheels[1].bounds.mean(0)[ax]:
+        wheels[0], wheels[1] = wheels[1], wheels[0]
+    if wheels[2].bounds.mean(0)[ax] > wheels[3].bounds.mean(0)[ax]:
+        wheels[2], wheels[3] = wheels[3], wheels[2]
+    
+    return [body] + wheels
+
+def split_body_back(back_type, annot, drivaernet_world=True):
+    """
+    Split DrivAerNet++ annotation parts into body and back parts.
+
+    Args:
+        back_type: car type, one of "E", "F", or "N". (or the full instance name)
+        annot: dict of trimesh objects, named as in the annotation STL file.
+        drivaernet_world: whether the annots are in DrivAerNet++ or normalized space.
+    
+    Returns:
+        body and back meshes.
+    """
+    back_type = back_type[0]  # in case full instance name is given
+    body, back = [], []
+    for key, part in annot.items():
+        if key in BACK_ANNOTS[back_type]:
+            back.append(part)
+        else:
+            body.append(part)
+    body = trimesh.util.concatenate(body)
+    back = trimesh.util.concatenate(back)
+    # Mirror them as the annotations are given for the left half of the car
+    body2 = body.copy()
+    back2 = back.copy()
+    ax = 1 if drivaernet_world else 2
+    body2.vertices[:, ax] = -body2.vertices[:, ax]
+    back2.vertices[:, ax] = -back2.vertices[:, ax]
+    body2.invert()
+    back2.invert()
+    body = trimesh.util.concatenate([body, body2])
+    back = trimesh.util.concatenate([back, back2])
+    return body, back

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/src/mesh.py

@@ -0,0 +1,314 @@
+"""
+Module for creating and dealing with meshes.
+"""
+
+import time
+
+import numpy as np
+import trimesh
+from skimage.measure import marching_cubes
+import torch
+
+from .utils import make_grid, compute_sdf, get_device
+
+
+@torch.no_grad()
+def create_mesh(model, idx, latents=None, N=256, max_batch=32**3, verbose=False, grid_filler=False, device=get_device(),
+                occ_tau=0.1, **model_kwargs):
+    """
+    Reconstruct the mesh from the latent vector(s).
+
+    Args:
+        model (nn.Module): INR model.
+        latent (torch.Tensor): latent vector(s) of the shape to mesh.
+        N (int): resolution of the grid.
+        max_batch (int): maximum batch size for predictions.
+        verbose (bool): enable verbosity.
+        grid_filler (bool or SdfGridFiller): whether to use an SdfGridFiller.
+        device (str or Device): device to use.
+        occ_tau (float): temperature scaling for occupancy (if relevant).
+        model_kwargs (dict): additional keyword arguments for the model, such as pose.
+    """
+    use_occ = hasattr(model, 'use_occ') and model.use_occ  # whether to use occupancy instead of SDF
+    # Compute the SDF values on a grid (fast or exact)
+    if not use_occ and isinstance(grid_filler, SdfGridFiller):
+        sdf_grid = grid_filler.fill_grid(grid_filler.make_sdf_func(model, idx, latents=latents, max_batch=max_batch, **model_kwargs), verbose=verbose)
+        N = grid_filler.N_max
+    elif not use_occ and grid_filler:
+        gf = SdfGridFiller(N, device="cpu")
+        sdf_grid = gf.fill_grid(gf.make_sdf_func(model, idx, latents=latents, max_batch=max_batch, **model_kwargs), device="cpu", verbose=verbose)
+    else:
+        sdf_grid = compute_sdf_grid(model, idx, latents=latents, N=N, max_batch=max_batch, verbose=verbose, device=device, **model_kwargs)
+    # Marching cubes
+    if use_occ:
+        level, gradient_direction = 0.5, 'ascent'
+        sdf_grid = torch.sigmoid(sdf_grid * occ_tau)  # temperature scaling to smoothen Marching-Cubes results
+    else:
+        level, gradient_direction = 0., 'descent'
+    mesh = convert_sdf_grid_to_mesh(sdf_grid, voxel_size=2. / (N - 1), level=level, gradient_direction=gradient_direction)
+    return mesh
+
+
+@torch.no_grad()
+def create_parts(model, latent, N=256, max_batch=32**3, verbose=False, grid_filler=False, device=get_device(), 
+                 occ_tau=0.1, **model_kwargs):
+    """
+    Reconstruct the individual parts from the latent vector(s).
+
+    Args:
+        model (nn.Module): INR model.
+        latent (torch.Tensor): latent vector(s) of the shape to mesh.
+        N (int): resolution of the grid.
+        max_batch (int): maximum batch size for predictions.
+        verbose (bool): enable verbosity.
+        grid_filler (bool or SdfGridFiller): whether to use an SdfGridFiller.
+        device (str or Device): device to use.
+        occ_tau (float): temperature scaling for occupancy (if relevant).
+        model_kwargs (dict): additional keyword arguments for the model, such as pose.
+    """
+    use_occ = hasattr(model, 'use_occ') and model.use_occ  # whether to use occupancy instead of SDF
+    # Compute the SDF values on a grid (fast or exact)
+    if use_occ or not grid_filler:
+        sdf_grid = compute_sdf_grid(model, latent, N=N, return_parts=True, max_batch=max_batch, 
+                                    verbose=verbose, device=device, **model_kwargs)
+    else:
+        if not isinstance(grid_filler, SdfGridFiller):
+            grid_filler = SdfGridFiller(N, device="cpu")
+        sdf_grid = torch.stack([
+            grid_filler.fill_grid(grid_filler.make_sdf_func(model, latent, max_batch, i, **model_kwargs), device="cpu", verbose=verbose)
+            for i in range(model.n_parts)
+        ], dim=-1)
+        N = grid_filler.N_max
+    # Marching cubes
+    if use_occ:
+        level, gradient_direction = 0.5, 'ascent'
+        sdf_grid = torch.sigmoid(sdf_grid * occ_tau)  # temperature scaling to smoothen Marching-Cubes results
+    else:
+        level, gradient_direction = 0., 'descent'
+    parts = [convert_sdf_grid_to_mesh(sdf_grid[..., i], voxel_size=2. / (N - 1), level=level, gradient_direction=gradient_direction)
+             for i in range(sdf_grid.shape[-1])]
+    return parts
+
+
+def compute_sdf_grid(model, idx, latents=None, N=256, max_batch=32**3, bbox=[(-1., -1., -1.), (1., 1., 1.)], 
+                     return_parts=False, verbose=False, device=get_device(), **model_kwargs):
+    """
+    Compute the SDF values over a grid in the given bounding box.
+
+    Args:
+        model (nn.Module): INR model.
+        latent (torch.Tensor): latent vector(s) of the shape.
+        N (int): resolution of the grid.
+        max_batch (int): maximum batch size for predictions.
+        bbox (list): bounding box of the grid, a list of the min and max coordinates.
+        return_parts (bool): whether to return the parts SDFs.
+        verbose (bool): enable verbosity.
+        device (str or Device): device to use.
+        model_kwargs (dict): additional keyword arguments for the model, such as pose.
+    """
+    # Create points on a grid
+    xyz = make_grid(bbox, N, device=device)
+
+    # Predict the SDF values on the grid
+    sdf = compute_sdf(model, idx, xyz, return_parts=return_parts, max_batch=max_batch, verbose=verbose, latents=latents, device=device, **model_kwargs)  
+    return sdf.squeeze(-1)
+
+
+def convert_sdf_grid_to_mesh(sdf_grid, voxel_size=1., voxel_origin=[-1., -1., -1.], level=0.,
+                             gradient_direction='descent', trimesh_process=True):
+    """
+    Convert the grid of SDF values to a mesh.
+
+    Args:
+        sdf_grid (torch.Tensor or np.ndarray): grid of SDF values.
+        voxel_size (float or list): size of the voxels.
+        voxel_origin (list): origin of the voxel grid.
+        level (float): level to extract the mesh.
+        gradient_direction (str): direction of the gradient ('descent' for SDF, 'ascent' for OCC).
+        trimesh_process (bool): whether to process the mesh with trimesh.
+    """
+    if not isinstance(sdf_grid, np.ndarray):
+        sdf_grid = sdf_grid.detach().cpu().numpy()
+    if isinstance(voxel_size, (int, float)):
+        voxel_size = [voxel_size] * 3
+    
+    try:
+        verts, faces, _, _ = marching_cubes(sdf_grid, level=level, spacing=voxel_size, 
+                                            gradient_direction=gradient_direction)
+        verts += np.array(voxel_origin)
+    except ValueError:  # no surface within range
+        verts, faces = None, None
+
+    return trimesh.Trimesh(verts, faces, process=trimesh_process)
+
+
+class SdfGridFiller():
+    """
+    Smart grid filler that starts at low resolution and go up by querying coordinates
+    where the SDF is low instead of the whole grid.
+
+    Adapted from Benoit Guillard.
+    """
+    
+    def __init__(self, N_max, device=get_device()):
+        """
+        Initialize the grid filler.
+
+        Construct grid and precompute sparse masks, from 32 to N_max.
+        
+        Args:
+        -----
+        N_max : int
+            Maximum resolution of the grid.
+        device: str or Device (default=cuda if available)
+            Device where the xyz coords are stored (trade-off memory vs computation).
+        """
+        # Save attributes
+        self.N_max = N_max
+        
+        # Create the coords grid (N,N,N,3) where 3 = x,y,z
+        xyz = make_grid([(-1., -1., -1.), (1., 1., 1.)], N_max)
+        xyz.pin_memory()
+        self.xyz = xyz.reshape(-1, 3).to(device)
+        
+        # Precompute binary masks for sparsely adressing the above grid
+        self.N_levels = [32 * (2**i) for i in range(int(np.log2(N_max) - 4))] # Minimum level = 32
+        mask = torch.zeros((N_max, N_max, N_max), dtype=bool, pin_memory=True)
+        # Fill dictionaries with precomputed masks
+        self.masks_coarse = {}
+        self.masks_coarse_no_recompute = {}
+        self.idxs_coarse_neighbors_blocks = {}
+        for i, N in enumerate(self.N_levels):
+            step = N_max // N
+            #### 1: Subsample coarsely
+            mask_coarse = mask.clone()
+            mask_coarse[::step, ::step, ::step] = True
+            # (N_max**3) array, with True only for indices of the coarse sampling (N**3 locations):
+            mask_coarse = mask_coarse.reshape(-1) 
+            self.masks_coarse[i] = mask_coarse.clone().to(self.xyz.device)
+
+            #### 2: Compute the idxs of neighboring blocks
+            neighbors_block_coarse = mask.clone()
+            neighbors_block_coarse[:step, :step, :step] = True
+            neighbors_block_coarse = neighbors_block_coarse.reshape(-1)
+            # Shape (N_max**3 // N, N): idxs_coarse_neighbors_blocks[i] represents the (N_max // N)**3 indexes covered by coarse point i
+            idxs_coarse_neighbors_blocks = torch.where(mask_coarse)[0].reshape(-1,1) + torch.where(neighbors_block_coarse)[0].reshape(1,-1)
+            self.idxs_coarse_neighbors_blocks[i] = idxs_coarse_neighbors_blocks.clone().to(self.xyz.device)
+
+            #### 3: If at a level >0, do not recompute already queried SDFs
+            if i > 0:
+                mask_coarse_no_recompute = mask_coarse.clone()
+                mask_coarse_no_recompute[self.masks_coarse[i-1]] = False
+                self.masks_coarse_no_recompute[i] = mask_coarse_no_recompute.clone().to(self.xyz.device)
+
+                
+    @torch.no_grad()
+    def fill_grid(self, sdf_func, return_queries=False, device=get_device(), verbose=False):
+        """
+        Fill the SDF grid by increasing resolution.
+
+        Args:
+        -----
+        sdf_func: callable (N, 3) -> (N)
+            Function that takes a batch of coordinates and returns the SDF values.
+        return_queries: bool (default=False)
+            Also return the number of queried points.
+        device: str (default="cuda:0" if available)
+            Device where the SDF grid is stored.
+        
+        Returns:
+        --------
+        sdf_values: torch.Tensor, shape (N_max, N_max, N_max)
+            The SDF values on the grid.
+        queries_number: int (optional, if return_queries)
+            The number of queries made to the network.
+        """
+        if verbose:
+            start_time = time.time()
+        if return_queries:
+            queries_number = 0
+        
+        sdf_values = torch.zeros(len(self.xyz), device=device)
+        close_surface_masks = {}
+        idxs_coarse_neighbors_blocks_LOCAL = {}
+        for level, N in enumerate(self.N_levels):
+            # Prepare masks based on previous levels
+            if level == 0:
+                mask_coarse = self.masks_coarse[level]
+                idxs_coarse_neighbors_blocks = self.idxs_coarse_neighbors_blocks[level].clone()
+                mask_coarse_no_recompute = self.masks_coarse[level]
+            else:
+                # Mask using previous queries
+                # binary mask
+                mask_coarse = self.masks_coarse[level].clone()
+                for l in range(level):
+                    mask_coarse[idxs_coarse_neighbors_blocks_LOCAL[l][~close_surface_masks[l]]] = False
+                # idx tensor
+                if N < self.N_max:
+                    idxs_coarse_neighbors_blocks = self.idxs_coarse_neighbors_blocks[level].clone()
+                    idxs_coarse_neighbors_blocks = idxs_coarse_neighbors_blocks[mask_coarse[self.masks_coarse[level]]]
+                else:
+                    idxs_coarse_neighbors_blocks = self.idxs_coarse_neighbors_blocks[level]
+                # The no_recompute version does not re-query the decoder for nodes that have already been (1/8th is saved)
+                mask_coarse_no_recompute = self.masks_coarse_no_recompute[level].clone()
+                for l in range(level):
+                    mask_coarse_no_recompute[idxs_coarse_neighbors_blocks_LOCAL[l][~close_surface_masks[l]]] = False
+            
+            idxs_coarse_neighbors_blocks_LOCAL[level] = idxs_coarse_neighbors_blocks
+            # Query the network
+            if return_queries:
+                queries_number += mask_coarse_no_recompute.sum().item() # count the total number of network queries
+            xyz = self.xyz[mask_coarse_no_recompute]
+            # Query + fill grid
+            sdf_values[mask_coarse_no_recompute] = sdf_func(xyz).detach().to(device)
+
+            # Prepare next levels queries
+            if N < self.N_max:
+                ## Which samples are close to the surface? (NOTE: where do current thresholds come from?)
+                STEP_SIZE = 2. / N
+                close_surface_mask = (torch.abs(sdf_values[mask_coarse.to(device)]) < 1.5 * 1.7 * STEP_SIZE)
+                close_surface_masks[level] = close_surface_mask
+                # For those far of the surface, we can ignore them for the future 
+                # and copy the high value to their neighbors
+                sdf_values[idxs_coarse_neighbors_blocks[~close_surface_mask]] = sdf_values[mask_coarse.to(device)][~close_surface_mask].unsqueeze(-1)
+        
+        sdf_values = sdf_values.reshape(self.N_max, self.N_max, self.N_max)
+        if verbose:
+            print(f"sdf-prediction took {time.time() - start_time:.3f}s.")   
+        if return_queries:
+            return sdf_values, queries_number
+        return sdf_values
+    
+    
+    @torch.no_grad()
+    def make_sdf_func(self, model, idx, latents=None, max_batch=32**3, part_idx=None, device=get_device(), **model_kwargs):
+        """Make an SDF function out of a model and latent vector."""
+        if idx.dim() == 0:
+            idx = idx.unsqueeze(0).to(device)
+
+        def sdf_func(xyz, latents=latents, max_batch=max_batch):
+            model.eval()
+
+            # Prepare data
+            xyz_all = xyz.view(-1, 3)
+            n_points = len(xyz_all)
+            sdf = torch.zeros(n_points, device=device)
+            # Predict SDF on a subset of points at a time
+            for i in range(0, n_points, max_batch):
+                xyz_subset = xyz_all[i : i + max_batch].to(device).unsqueeze(0)
+                if part_idx is not None:
+                    sdf[i : i + max_batch] = model(idx, xyz_subset, latents=latents, return_parts=True, **model_kwargs).squeeze().detach().to(device)
+                else:
+                    sdf[i : i + max_batch] = model(idx, xyz_subset, latents=latents, **model_kwargs).squeeze().detach().to(device)
+
+            return sdf.view(xyz.shape[:-1])
+        
+        return sdf_func
+    
+
+    @torch.no_grad()
+    def make_mesh(self, sdf_func, return_queries=False, device=get_device(), verbose=False):
+        """Mesh an SDF function."""
+        sdf_grid = self.fill_grid(sdf_func, return_queries=return_queries, 
+                                  device=device, verbose=verbose)
+        return convert_sdf_grid_to_mesh(sdf_grid, voxel_size=2. / (self.N_max - 1))

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/src/optimization.py

@@ -0,0 +1,258 @@
+import trimesh
+import numpy as np
+import torch
+import json
+import sys
+import os
+
+from src.mesh import SdfGridFiller, create_mesh
+
+sys.path.append("/mnt/cvlab/scratch/cvlab/home/hantzhan/surrogates/Transolver/")
+from TransolverNeMo.transolver import Transolver # type: ignore
+
+
+DEFAULT_SPECS_PATH = {"Transolver_Drivernet": "/mnt/cvlab/scratch/cvlab/home/hantzhan/surrogates/Transolver/experiments/drivaernet/transolver_S/specs.json"}
+DEFAULT_MODEL_PATH = {"Transolver_Drivernet": "/mnt/cvlab/scratch/cvlab/home/hantzhan/surrogates/Transolver/experiments/drivaernet/transolver_S/model/model_100.pth"}
+
+DATASET_CONSTANTS = {
+    "DriverNet": {
+        "RHO": 1.184,
+        "MAGUINF": 30.,
+        "P_MAX": 2000,
+        "P_MEAN": -93.39186,
+        "P_STD": 120.2923,
+        "CD_MEAN": 0.26285287093925974,
+        "CD_STD": 0.020127521964890926,
+        "T_TRANSFORM": np.array([(4.1 - 1.05) / 2, -0.7, 0.0]),
+        "R_TRANSFORM": np.array([[-1, 0, 0], [0, 0, 1], [0, 1, 0]]),
+        "S_TRANSFORM": 2 * 0.9 / (4.1 + 1.05)
+    }
+}
+
+RHO=1.184
+MAGUINF=30
+P_MAX=2000
+P_MEAN= -93.39186
+P_STD= 120.2923
+CD_MEAN= 0.26285287093925974
+CD_STD= 0.020127521964890926
+T_DRIVAERNET= torch.tensor([(4.1 - 1.05) / 2, -0.7, 0.0]).to("cuda").float()
+R_DRIVAERNET= torch.tensor([[-1, 0, 0], [0, 0, 1], [0, 1, 0]]).to("cuda").float()
+S_DRIVAERNET= 2 * 0.9 / (4.1 + 1.05)
+
+def load_surr_model(device: str = "cuda"):
+    surr_specs = {"SurrogateType" : "Transolver_Drivernet",
+        "OptimizationArgs" : {
+            "drag_weight": 1,
+            "VoxelGrid": [64, 64, 64],
+            "norm_drag": True,
+            "Aref_init": 1,
+            "drivernet": True
+        }}
+    model_path = DEFAULT_MODEL_PATH["Transolver_Drivernet"]
+    specs_path = DEFAULT_SPECS_PATH["Transolver_Drivernet"]
+    if not os.path.exists(specs_path) or not os.path.exists(model_path):
+        raise FileNotFoundError(f"File not found: {specs_path} or {model_path}")
+
+    with open(specs_path, 'r') as f:
+        surr_specs = json.load(f)
+
+    surr_model = Transolver(**surr_specs["ModelParameters"], use_te=False).to(device)
+    state_dict = torch.load(model_path, map_location=device)
+    surr_model.load_state_dict(state_dict)
+
+    surr_model.eval()
+    for p in surr_model.parameters():
+        p.requires_grad = False
+    return surr_specs, surr_model
+
+# def surr_predict_mesh(mesh, model, verts=None, device="cuda", max_points=500_000):
+#     verts = verts.to(device) if verts is not None else torch.from_numpy(mesh.vertices).float().clone().to(device)
+#     normals = torch.from_numpy(mesh.vertex_normals).float().clone().to(device)
+#     if max_points is not None and len(verts) > max_points:
+#         indices = torch.randperm(len(verts))[:max_points]
+#         verts = verts[indices]
+#         normals = normals[indices]
+#     # Denormalize into DrivAerNet++ space (expected by the surrogate)
+
+#     verts = (verts / S_DRIVAERNET - T_DRIVAERNET) @ R_DRIVAERNET
+#     normals = normals @ R_DRIVAERNET
+#     data = torch.cat([verts, normals, torch.zeros_like(verts[..., :1])], dim=-1).unsqueeze(0)
+#     out = model(torch.empty_like(data[..., :0]), data)
+#     if hasattr(model, "scalar_decoder") and model.scalar_decoder:
+#         return out[0][0, ..., 0] * P_STD + P_MEAN, out[1][0, ..., 0] * CD_STD + CD_MEAN
+#     else:
+#         return out[0, ..., 0] * P_STD + P_MEAN
+
+def surr_predict_mesh(mesh, model, verts=None, device="cuda", max_points=500_000):
+    verts = verts.to(device) if verts is not None else torch.from_numpy(mesh.vertices).float().clone().to(device)
+    normals = torch.from_numpy(mesh.vertex_normals).float().clone().to(device)
+    
+    if max_points is not None and len(verts) > max_points:
+        indices = torch.randperm(len(verts))[:max_points]
+        verts = verts[indices]
+        normals = normals[indices]
+
+    # ==========================================
+    # FUSION DES TRANSFORMATIONS (Sans gradients)
+    # ==========================================
+    with torch.no_grad():
+        v_min, _ = verts.min(dim=0)
+        v_max, _ = verts.max(dim=0)
+        bbox_center = (v_max + v_min) / 2.0
+        max_extent = (v_max - v_min).max()
+        
+        # 1. Mise à l'échelle combinée (Hunyuan -> 0.9 -> DrivAer)
+        scale_factor = 1.8 / max_extent
+        combined_scale = scale_factor / S_DRIVAERNET
+        
+        # 2. Matrice d'inversion X
+        F = torch.tensor([[-1.,  0.,  0.],
+                          [ 0.,  1.,  0.],
+                          [ 0.,  0.,  1.]], device=device)
+        
+        # 3. MATRICE COMBINÉE M (Echelle + Flip + Rotation)
+        # On multiplie les matrices : Scale * (Flip @ Rotation)
+        M = combined_scale * (F @ R_DRIVAERNET)
+        
+        # 4. TRANSLATION COMBINÉE T (Centrage + Translation DrivAer + Rotation)
+        flip_vector = torch.tensor([-1., 1., 1.], device=device)
+        center_scaled_flipped = bbox_center * combined_scale * flip_vector
+        T_final = - (center_scaled_flipped + T_DRIVAERNET) @ R_DRIVAERNET
+        
+        # 5. Matrice pour les normales (Seulement Flip + Rotation, l'échelle uniforme ne change pas la direction)
+        M_normals = F @ R_DRIVAERNET
+
+    # ==========================================
+    # APPLICATION EN UNE FOIS (Avec gradients)
+    # ==========================================
+    
+    verts_drivaer = verts @ M + T_final
+    normals_drivaer = normals @ M_normals
+    
+    # ==========================================
+    # Prédiction du modèle
+    # ==========================================
+    data = torch.cat([verts_drivaer, normals_drivaer, torch.zeros_like(verts_drivaer[..., :1])], dim=-1).unsqueeze(0)
+    out = model(torch.empty_like(data[..., :0]), data)
+    
+    if hasattr(model, "scalar_decoder") and model.scalar_decoder:
+        return out[0][0, ..., 0] * P_STD + P_MEAN, out[1][0, ..., 0] * CD_STD + CD_MEAN
+    else:
+        return out[0, ..., 0] * P_STD + P_MEAN
+
+
+def get_vector_areas(vertices, faces):
+    """
+    Get the vector areas of the mesh defined by its vertices and faces:
+        s_i = n_i * a_i = AB x AC / 2
+    with n_i the normal and a_i the surface of the face; ABC are the vertices of the 
+    triangle and 'x' is the cross operator.
+    """
+    return torch.cross(vertices[faces[:,1]] - vertices[faces[:,0]],
+                       vertices[faces[:,2]] - vertices[faces[:,0]]) / 2
+
+
+def find_Aref(mesh, ray_per_dim=512):
+    """Approximate frontal area by intersecting rays."""
+    y_min, y_max = mesh.bounds[:,1]
+    z_min, z_max = mesh.bounds[:,2]
+    yz_area = (y_max - y_min) * (z_max - z_min)
+    YZ = np.stack(np.meshgrid(
+        np.linspace(y_min, y_max, ray_per_dim), 
+        np.linspace(z_min, z_max, ray_per_dim),
+        indexing='xy'
+    ), axis=-1).reshape(-1, 2)
+    YZ = np.concatenate([np.full_like(YZ[:,0:1], 2), YZ], axis=1)
+    
+    intersections = mesh.ray.intersects_any(YZ, [[-1,0,0]]* len(YZ))
+    return yz_area * intersections.mean()
+
+
+def get_drag_loss(p, verts, faces, rho, magUInf, Aref=None, norm=False):
+    """
+    Compute the (pressure) drag coefficient of the mesh and its pressure field.
+    Note: rho and magUInf are now explicit required arguments.
+    """
+    p_faces = p[faces].mean(-1, keepdims=True)
+    vector_areas = get_vector_areas(verts, faces)
+    p_force = - rho * p_faces * vector_areas
+    Fd = torch.abs(p_force[:, 0].sum())
+    if norm:
+        Aref = find_Aref(trimesh.Trimesh(verts.detach().cpu().numpy(), faces.detach().cpu().numpy()), 256) if Aref is None else Aref 
+        return 2 * Fd / (rho * magUInf * magUInf * Aref)
+    else:
+        return Fd
+
+
+def get_Aref_init(model, idx_sample, device, latents=None):
+    """
+    Compute the reference area A_ref for a given shape represented by an SDF model.
+
+    The reference area is estimated from the initial mesh extracted from the SDF
+    and is typically used to normalize aerodynamic quantities (e.g. drag coefficient).
+
+    Args:
+        model: Trained SDF model.
+        idx_sample: Index (or latent code index) of the shape to evaluate.
+        device: Torch device ("cpu" or "cuda").
+
+    Returns:
+        Aref_init (float): Reference area of the initial shape.
+    """
+    grid_filler = SdfGridFiller(N_max = 128, device=device)
+
+    mesh_init = create_mesh(model, idx=idx_sample, latents=latents, N=grid_filler.N_max, grid_filler=grid_filler)
+
+    Aref_init = find_Aref(mesh_init, 256)
+    return Aref_init
+
+
+def compute_drag(xyz, model, index_samples, latents=None, device="cuda", only_drag=False, **kwargs):
+    # Extract kwargs
+    surr_model = kwargs.get("surr_model")
+    grid_filler = kwargs.get("grid_filler")
+    Aref_init = kwargs.get("Aref_init", None)
+    norm_drag = kwargs.get("norm_drag", True)
+    
+    const = DATASET_CONSTANTS["DriverNet"]
+    # Build mesh from SDF
+    mesh = grid_filler.make_mesh(
+        grid_filler.make_sdf_func(model, index_samples, latents=latents)
+    )
+    verts = torch.from_numpy(mesh.vertices).float().to(device).requires_grad_(True)
+    faces = torch.from_numpy(mesh.faces).to(device)
+
+    # Forward drag prediction
+    p_pred = surr_predict_mesh(mesh=mesh, model=surr_model, device=device, verts=verts)
+
+    # Pass the correct physical constants to the drag calculation
+    drag = get_drag_loss(
+        p_pred, verts, faces,
+        rho=const["RHO"],
+        magUInf=const["MAGUINF"],
+        Aref=Aref_init,
+        norm=norm_drag
+    )
+
+    target_drag = kwargs.get("target_drag", None)
+    if target_drag is not None:
+        if not isinstance(target_drag, torch.Tensor):
+            target_drag = torch.tensor([target_drag], device=device, dtype=torch.float32)
+        
+        loss_drag_optim = torch.pow(drag - target_drag, 2) 
+    else:
+        loss_drag_optim = drag
+    # ---------------------------------------------------------
+
+    if not only_drag:
+        dL_dv = torch.autograd.grad(loss_drag_optim, verts, retain_graph=True)[0].detach()
+        
+        sdf_pred = model(index_samples, verts.unsqueeze(0), latents=latents)
+        grad_sdf = torch.autograd.grad(sdf_pred.sum(), verts, retain_graph=True)[0]
+        normals = grad_sdf / (grad_sdf.norm(dim=1, keepdim=True) + 1e-8)
+        dL_ds = - torch.sum(dL_dv * normals, dim=-1, keepdim=True)
+        loss = torch.sum(dL_ds.detach() * sdf_pred)
+        return loss, drag 
+    else:
+        return drag

cfd_workflow_20261012/_seiler_ref/drivernet_hunyuan_code/src/utils.py

@@ -0,0 +1,375 @@
+"""
+Utilities module.
+"""
+
+import sys
+import random
+import logging
+import io
+import time
+import colorsys
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from PIL import Image
+import igl
+import torch
+
+import torch.nn.functional as F
+
+###########
+# General #
+###########
+
+def set_seed(seed):
+    """Set the manual seeds for python, numpy, and pytorch."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def get_device():
+    """Get the device to use for computation."""
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+    elif torch.backends.mps.is_available() and torch.backends.mps.is_built():
+        device = torch.device("mps")
+    else:
+        device = torch.device("cpu")
+    return device
+
+
+def unwrap_model(model):
+    """Return the underlying model if wrapped in DataParallel or DDP."""
+    if isinstance(model, (torch.nn.DataParallel, torch.nn.parallel.DistributedDataParallel)):
+        return model.module
+    return model
+
+
+def configure_logging(args=None, logfile=None):
+    logger = logging.getLogger()
+
+    if logger.hasHandlers():
+            logger.handlers.clear()
+    if args is None:
+        logger.setLevel(logging.INFO)
+    elif "debug" in args and args.debug:
+        logger.setLevel(logging.DEBUG)
+    elif "verbose" in args and not args.verbose:
+        logger.setLevel(logging.WARNING)
+    else:
+        logger.setLevel(logging.INFO)
+
+    # Edit display of level names
+    for level, levelname in zip([logging.CRITICAL, logging.ERROR, logging.WARNING, logging.DEBUG],
+                                ['CRITICAL', 'ERROR', 'WARNING', 'DEBUG']):
+        logging.addLevelName(level, levelname + ': ')
+    logging.addLevelName(logging.INFO, '')
+    formatter = logging.Formatter("%(levelname)s%(message)s")
+
+    # Log in stream
+    logger_handler = logging.StreamHandler()
+    logger_handler.setFormatter(formatter)
+    logger.addHandler(logger_handler)
+
+    # Log in file
+    if logfile is not None:
+        file_logger_handler = logging.FileHandler(logfile)
+        file_logger_handler.setFormatter(formatter)
+        logger.addHandler(file_logger_handler)
+    
+    # Automatically log exceptions
+    def handle_exception(exc_type, exc_value, exc_traceback):
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        logger.critical("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
+    sys.excepthook = handle_exception
+
+    # Deal with verbose loggers
+    plt.set_loglevel(level='info')
+    pil_logger = logging.getLogger('PIL')  
+    pil_logger.setLevel(logging.INFO)
+
+
+#######
+# SDF #
+#######
+
+def compute_sdf(model, idx, xyz, latents=None, return_parts=False, max_batch=32**3, verbose=False, device=get_device(), **model_kwargs):
+    """
+    Compute the SDF values for a single shape at the given positions.
+
+    Args:
+    -----
+    model: nn.Module
+        The model to evaluate.
+    latent: torch.Tensor, shape (1, latent_size)
+        The latent vector of the shape.
+    xyz: torch.Tensor, shape ([N], 3)
+        The positions to evaluate the SDF at.
+    return_parts: bool
+        Whether to return the SDFs for each part.
+    max_batch: int (default=32**3)
+        The maximum number of points to evaluate at once.
+    verbose: bool (default=False)
+        If True, print the time taken for the computation.
+    device: str (default="cuda:0" if available)
+        The device to use to store the final SDF values.
+    **model_kwargs: (optional)
+        Additional key-worded arguments to pass to the model.
+    
+    Returns:
+    --------
+    sdf: torch.Tensor, shape ([N], 1) or ([N], n_parts, 1) if return_parts
+        The SDF values at the given positions.
+    """
+    if verbose:
+        start_time = time.time()
+    model.eval()
+
+    # Prepare data
+    xyz_all = xyz.view(-1, 3)
+    if not xyz_all.is_cuda:
+        xyz_all = xyz_all.pin_memory()
+    n_points = len(xyz_all)
+    if return_parts:
+        sdf = torch.zeros(n_points, model.n_parts, device=device)
+    else:
+        sdf = torch.zeros(n_points, device=device)
+
+    # Predict SDF on a subset of points at a time
+    if idx.dim() == 0:
+        idx = idx.unsqueeze(0)
+    for i in range(0, n_points, max_batch):
+        xyz_subset = xyz_all[i : i + max_batch].to(device).unsqueeze(0)
+        if return_parts:
+            sdf[i : i + max_batch] = model(idx, xyz_subset, latents=latents, return_parts=True, **model_kwargs).squeeze().detach().to(device)
+        else:
+            sdf[i : i + max_batch] = model(idx, xyz_subset, latents=latents, **model_kwargs).squeeze().detach().to(device)
+
+    if verbose:
+        print(f"sdf-prediction took {time.time() - start_time:.3f}s.")
+    if return_parts:
+        return sdf.view(xyz.shape[:-1] + (model.n_parts, 1))
+    return sdf.view(xyz.shape[:-1] + (1,))
+
+
+def clamp_sdf(sdf, clampD, ref=None):
+    """
+    Clamp the SDF, optionally based on a reference.
+    If ref is given, then the clamping is dependent on it:
+    e.g., sdf is clamped by +clampD only where ref >= +clampD.
+    """
+    if ref is None:
+        return torch.clamp(sdf, -clampD, clampD)
+    sdf = torch.where(ref > clampD, torch.clamp(sdf, max=clampD), sdf)
+    sdf = torch.where(ref < -clampD, torch.clamp(sdf, min=-clampD), sdf)
+    return sdf
+
+
+def compute_gradients(sdf: torch.Tensor) -> torch.Tensor:
+    """
+    Compute spatial gradients of a batched SDF tensor using finite differences.
+
+    Parameters
+    ----------
+    sdf : torch.Tensor
+        Tensor of shape (B, 1, D, H, W) representing the scalar field (e.g., SDF values).
+
+    Returns
+    -------
+    grad : torch.Tensor
+        Tensor of shape (B, 3, D, H, W) containing gradients along x, y, z axes.
+    """
+    if sdf.dim() != 5:
+        raise ValueError(f"sdf must have shape (B, 1, D, H, W), got {tuple(sdf.shape)}")
+
+    # Pad for central differences (replicate border to keep same shape)
+    sdf_padded = F.pad(sdf, (1, 1, 1, 1, 1, 1), mode='replicate')
+
+    # Finite differences
+    gx = (sdf_padded[:, :, 1:-1, 1:-1, 2:] - sdf_padded[:, :, 1:-1, 1:-1, :-2]) / 2.0
+    gy = (sdf_padded[:, :, 1:-1, 2:, 1:-1] - sdf_padded[:, :, 1:-1, :-2, 1:-1]) / 2.0
+    gz = (sdf_padded[:, :, 2:, 1:-1, 1:-1] - sdf_padded[:, :, :-2, 1:-1, 1:-1]) / 2.0
+
+    grad = torch.cat([gx, gy, gz], dim=1)  # (B, 3, D, H, W)
+    return grad
+
+
+def make_grid(bbox, N, device=None):
+    """Create points on a regular grid."""
+    if isinstance(N, int):
+        N = [N] * len(bbox[0])
+    coords = []
+    for i in range(len(bbox[0])):
+        coords.append(torch.linspace(bbox[0][i], bbox[1][i], N[i], device=device))
+    coords = torch.meshgrid(*coords, indexing='ij')
+    coords = torch.stack(coords, dim=-1)
+    return coords
+
+
+def make_grid2d(bbox, N, axis=0, value=0., device=None):
+    """
+    Create points on a regular grid of a 2D slice of a 3D world.
+    
+    axis: int (default=0)
+        The axis index of the normal to the plane, e.g. 0 for x.
+    value: float (default=0.)
+        The second is the "fill" value along that axis, e.g. 0. for the x_i=0. plane.
+    """
+    assert axis in [0, 1, 2]
+
+    if isinstance(N, int):
+        N = [N] * 2
+    x1 = torch.linspace(bbox[0][0], bbox[1][0], N[0], device=device)
+    x2 = torch.linspace(bbox[0][1], bbox[1][1], N[1], device=device)
+    grid = torch.meshgrid(x1, x2, indexing='ij')
+    plane = torch.zeros_like(grid[0]) + value
+    if axis == 0:
+        xyz = torch.stack((plane, grid[0], grid[1]), dim=-1)
+    elif axis == 1:
+        xyz = torch.stack((grid[0], plane, grid[1]), dim=-1)
+    elif axis == 2:
+        xyz = torch.stack((grid[0], grid[1], plane), dim=-1)
+    return xyz
+
+
+def make_grid_image(bbox, N_max, axis=1, value=0., device=None):
+    """
+    Create points on a regular grid of a 2D slice, with number of pixels adapting from bbox.
+    
+    axis: int (default=0)
+        The axis index of the normal to the plane, e.g. 0 for x.
+    value: float (default=0.)
+        The second is the "fill" value along that axis, e.g. 0. for the x_i=0. plane.
+    """
+    assert axis in [0, 1, 2]
+
+    # Get resolution per axis
+    if not isinstance(bbox, np.ndarray):
+        bbox = np.array(bbox)
+    extent = np.abs(bbox[1] - bbox[0])
+    ratio = extent.min() / extent.max()
+    N_min = np.round(N_max * ratio).astype(int)
+    N = [N_max, N_min] if extent[0] > extent[1] else [N_min, N_max]
+    
+    x1 = torch.linspace(bbox[0][0], bbox[1][0], N[0], device=device)
+    x2 = torch.linspace(bbox[0][1], bbox[1][1], N[1], device=device)
+    grid = torch.meshgrid(x1, x2, indexing='ij')
+    plane = torch.zeros_like(grid[0]) + value
+    if axis == 0:
+        xyz = torch.stack((plane, grid[0], grid[1]), dim=-1)
+    elif axis == 1:
+        xyz = torch.stack((grid[0], plane, grid[1]), dim=-1)
+    elif axis == 2:
+        xyz = torch.stack((grid[0], grid[1], plane), dim=-1)
+    return xyz
+
+
+def get_sdf_mesh(mesh, xyz):
+    """Return the SDF of the mesh at the queried positions, using IGL."""
+    sdf = igl.signed_distance(xyz.reshape(-1, 3), mesh.vertices, mesh.faces)[0]
+    return sdf.reshape(xyz.shape[:-1])
+
+def get_winding_number_mesh(mesh, xyz, method='fast'):
+    """Return the winding number of the mesh at the queried positions, using IGL."""
+    if method == 'fast':
+        wn = igl.fast_winding_number(mesh.vertices, mesh.faces, xyz.reshape(-1, 3).astype(mesh.vertices.dtype))
+    else:
+        wn = igl.winding_number(mesh.vertices, mesh.faces, xyz.reshape(-1, 3).astype(mesh.vertices.dtype))
+    return wn.reshape(xyz.shape[:-1])
+
+
+##########
+# Meshes #
+##########
+
+def get_color_mesh(mesh, vertex_values, vmin=None, vmax=None, cmap=colormaps['viridis'], symmetric=False):
+    """Return a new mesh with the vertex colors set according to the values."""
+    if isinstance(cmap, str):
+        cmap = colormaps[cmap]
+    vmin = vertex_values.min() if vmin is None else vmin
+    vmax = vertex_values.max() if vmax is None else vmax
+    if symmetric:
+        vmax = max(abs(vmin), abs(vmax))
+        vmin = -vmax
+    mesh = mesh.copy()
+    vertex_values = (vertex_values - vmin) / (vmax - vmin)
+    mesh.visual.vertex_colors = cmap(vertex_values)
+    return mesh
+
+
+def get_color_parts(parts, colors=None, cmap=None):
+    """Color the parts of a mesh."""
+    if cmap is not None:
+        if isinstance(cmap, str):
+            cmap = colormaps[cmap]
+        colors = cmap(np.linspace(0, 1, len(parts)))
+    elif colors is None:
+            colors = generate_n_colors(len(parts))
+    parts = parts.copy()
+    for part, color in zip(parts, colors):
+        part.visual.face_colors = color
+    return parts
+
+
+###########
+# PyTorch #
+###########
+
+def get_gradient(inputs, outputs, retain_graph=True):
+    grads = torch.autograd.grad(
+        outputs.sum(), inputs,
+        create_graph=True,
+        retain_graph=retain_graph,
+        only_inputs=True
+    )
+    if isinstance(inputs, torch.Tensor):
+        grads = grads[0]
+    return grads
+
+
+def index_extract(tensor, indices):
+    """
+    Extract the elements of a tensor at the given indices.
+
+    Args:
+        tensor: torch.Tensor, shape ([B], N, [M]) to extract from
+        indices: torch.Tensor, shape ([B], 1) of indices
+    Returns:
+        torch.Tensor, shape ([B], [M]) of extracted elements
+            (note the removed dimension)
+    """
+    indices = indices.squeeze(-1)
+    dim = indices.ndim
+
+    # Work of flatten tensors
+    out = tensor.flatten(0, dim - 1)
+    indices = indices.flatten()
+    out = out[torch.arange(out.shape[0], device=out.device), indices]
+    return out.view(*tensor.shape[:dim], *tensor.shape[dim + 1:])
+
+
+#########
+# Misc. #
+#########
+
+def fig2img(fig):
+    """Convert a figure to an image."""
+    buf = io.BytesIO()
+    fig.savefig(buf)
+    buf.seek(0)
+    img = Image.open(buf)
+    return img
+
+
+def generate_n_colors(n, s=0.5, v=0.9):
+    """Generate N distinct colors in HSV space."""
+    colors = []
+    for i in range(n):
+        h = i / n
+        colors.append(colorsys.hsv_to_rgb(h, s, v))
+    return np.array(colors)

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/U

@@ -0,0 +1,88 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 1 -1 0 0 0 0 ];
+internalField uniform (30 0.0 0.0);
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+
+        type fixedValue;
+        value uniform ( 30.0 0.0 0.0 );
+
+/*
+        type            uniformFixedValue;
+        uniformValue    table
+	(
+            (0 	 	(5 0 0))
+            //(20 	(10 0 0))
+            //(40 	(15 0 0))
+            //(60 	(20 0 0))
+            //(80 	(25 0 0))
+            (100 	(30 0 0))
+	);
+*/
+
+    }
+
+    outlet
+    {
+        //type zeroGradient;
+        //value uniform ( 0.0 0.0 0.0 );
+
+	type		inletOutlet;
+	inletValue	uniform (30 0 0);
+	value		uniform (30 0 0);
+    }
+
+    sides
+    {
+        type slip;
+    }
+
+    ground
+    {
+        type fixedValue;
+        value uniform ( 30.0 0.0 0.0 );
+
+/*
+        type            uniformFixedValue;
+        uniformValue    table
+	(
+            (0 	 	(5 0 0))
+            //(20 	(10 0 0))
+            //(40 	(15 0 0))
+            //(60 	(20 0 0))
+            //(80 	(25 0 0))
+            (100 	(30 0 0))
+	);
+*/
+    }
+
+    top
+    {
+        type slip;
+    }
+
+    car
+    {
+        type fixedValue;
+        value uniform ( 0 0 0);
+    }
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/k

@@ -0,0 +1,60 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      k;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -2 0 0 0 0 ];
+internalField uniform 3.375;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type fixedValue;
+        value uniform 3.375;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+
+    sides
+    {
+        //type kqRWallFunction;
+        //value uniform 1e-20;
+        type slip;
+    }
+
+    ground
+    {
+        type kqRWallFunction;
+        value uniform 3.375;
+    }
+
+    top
+    {
+        //type kqRWallFunction;
+        //value uniform 1e-20;
+	type slip;
+    }
+
+    car
+    {
+        type kqRWallFunction;
+        value uniform 3.375;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/nut

@@ -0,0 +1,59 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      nut;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -1 0 0 0 0 ];
+internalField uniform 0.0001;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type zeroGradient;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+
+    sides
+    {
+        //type nutUSpaldingWallFunction;
+        //value uniform 0.001;
+        type slip;
+    }
+
+    ground
+    {
+        type nutUSpaldingWallFunction;
+        value uniform 0.0001;
+    }
+
+    top
+    {
+        //type nutUSpaldingWallFunction;
+        //value uniform 0.001;
+        type slip;
+    }
+
+    car
+    {
+        type nutUSpaldingWallFunction;
+        value uniform 0.0001;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/omega

@@ -0,0 +1,62 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      omega;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 0 -1 0 0 0 0 ];
+internalField uniform 9000;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type fixedValue;
+        value uniform 9000;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+    
+    sides
+    {
+        //type omegaWallFunction;
+        //value uniform 1;
+        type slip;
+    }
+
+    ground
+    {
+        type omegaWallFunction;
+        //value uniform 9000;
+        value uniform 500000;
+    }
+
+    top
+    {
+        //type omegaWallFunction;
+        //value uniform 1;
+        type slip;
+    }
+
+    car
+    {
+        type omegaWallFunction;
+        //value uniform 9000;
+        value uniform 500000;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0/p

@@ -0,0 +1,56 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -2 0 0 0 0 ];
+internalField uniform 0.0;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type zeroGradient;
+    }
+
+    outlet
+    {
+        type fixedValue;
+        value uniform 0.0;
+    }
+
+    sides
+    {
+        //type zeroGradient;
+        type slip;
+    }
+
+    ground
+    {
+        type zeroGradient;
+    }
+
+    top
+    {
+        //type zeroGradient;
+        type slip;
+    }
+
+    car
+    {
+        type zeroGradient;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/U

@@ -0,0 +1,88 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 1 -1 0 0 0 0 ];
+internalField uniform (30 0.0 0.0);
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+
+        type fixedValue;
+        value uniform ( 30.0 0.0 0.0 );
+
+/*
+        type            uniformFixedValue;
+        uniformValue    table
+	(
+            (0 	 	(5 0 0))
+            //(20 	(10 0 0))
+            //(40 	(15 0 0))
+            //(60 	(20 0 0))
+            //(80 	(25 0 0))
+            (100 	(30 0 0))
+	);
+*/
+
+    }
+
+    outlet
+    {
+        //type zeroGradient;
+        //value uniform ( 0.0 0.0 0.0 );
+
+	type		inletOutlet;
+	inletValue	uniform (30 0 0);
+	value		uniform (30 0 0);
+    }
+
+    sides
+    {
+        type slip;
+    }
+
+    ground
+    {
+        type fixedValue;
+        value uniform ( 30.0 0.0 0.0 );
+
+/*
+        type            uniformFixedValue;
+        uniformValue    table
+	(
+            (0 	 	(5 0 0))
+            //(20 	(10 0 0))
+            //(40 	(15 0 0))
+            //(60 	(20 0 0))
+            //(80 	(25 0 0))
+            (100 	(30 0 0))
+	);
+*/
+    }
+
+    top
+    {
+        type slip;
+    }
+
+    car
+    {
+        type fixedValue;
+        value uniform ( 0 0 0);
+    }
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/k

@@ -0,0 +1,60 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      k;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -2 0 0 0 0 ];
+internalField uniform 3.375;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type fixedValue;
+        value uniform 3.375;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+
+    sides
+    {
+        //type kqRWallFunction;
+        //value uniform 1e-20;
+        type slip;
+    }
+
+    ground
+    {
+        type kqRWallFunction;
+        value uniform 3.375;
+    }
+
+    top
+    {
+        //type kqRWallFunction;
+        //value uniform 1e-20;
+	type slip;
+    }
+
+    car
+    {
+        type kqRWallFunction;
+        value uniform 3.375;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/nut

@@ -0,0 +1,59 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      nut;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -1 0 0 0 0 ];
+internalField uniform 0.0001;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type zeroGradient;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+
+    sides
+    {
+        //type nutUSpaldingWallFunction;
+        //value uniform 0.001;
+        type slip;
+    }
+
+    ground
+    {
+        type nutUSpaldingWallFunction;
+        value uniform 0.0001;
+    }
+
+    top
+    {
+        //type nutUSpaldingWallFunction;
+        //value uniform 0.001;
+        type slip;
+    }
+
+    car
+    {
+        type nutUSpaldingWallFunction;
+        value uniform 0.0001;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/omega

@@ -0,0 +1,62 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      omega;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 0 -1 0 0 0 0 ];
+internalField uniform 9000;
+
+boundaryField
+{
+    #includeEtc "caseDicts/setConstraintTypes"
+    inlet
+    {
+        type fixedValue;
+        value uniform 9000;
+    }
+
+    outlet
+    {
+        type zeroGradient;
+    }
+    
+    sides
+    {
+        //type omegaWallFunction;
+        //value uniform 1;
+        type slip;
+    }
+
+    ground
+    {
+        type omegaWallFunction;
+        //value uniform 9000;
+        value uniform 500000;
+    }
+
+    top
+    {
+        //type omegaWallFunction;
+        //value uniform 1;
+        type slip;
+    }
+
+    car
+    {
+        type omegaWallFunction;
+        //value uniform 9000;
+        value uniform 500000;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/0_org/p

@@ -0,0 +1,55 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  7                                     |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [ 0 2 -2 0 0 0 0 ];
+internalField uniform 0.0;
+
+boundaryField
+{
+    inlet
+    {
+        type zeroGradient;
+    }
+
+    outlet
+    {
+        type fixedValue;
+        value uniform 0.0;
+    }
+
+    sides
+    {
+        //type zeroGradient;
+        type slip;
+    }
+
+    ground
+    {
+        type zeroGradient;
+    }
+
+    top
+    {
+        //type zeroGradient;
+        type slip;
+    }
+
+    car
+    {
+        type zeroGradient;
+    }
+
+}

cfd_workflow_20261012/_seiler_ref/example_INIT_30_sim/README.md

@@ -0,0 +1,2 @@
+# Experiment
+Template.