Kit-CAE Project Overview

Kit-CAE is a sample application on the NVIDIA Omniverse platform that demonstrates workflows for processing and rendering CAE (Computer-Aided Engineering) data.

Main Objectives of the Project

1. CAE Data Visualization: Process and visualize scientific simulation data in Omniverse
2. USD Schema Extension: Define new USD schemas for CAE data
3. Support for Various File Formats: CGNS, VTK, EnSight, NPZ, and more
4. Extensible Architecture: A structure that makes it easy to add new data models and algorithms

Core Structure

1. USD Schemas (usdSchema/)

• CaeDataSet: A new USD prim type representing a scientific dataset
• CaeFieldArray: A prim type representing an individual field array
• API Schemas: Single-apply API schemas for adding data-model-specific properties

2. Key Extensions

Data Processing Core:

• omni.cae.data: Provides the Data Delegate API
• omni.cae.algorithms.core: Manages algorithm execution

File Format Support:

• omni.cae.cgns: CGNS file support
• omni.cae.npz: NumPy file support
• omni.cae.vtk: VTK file support
• omni.cae.ensight: EnSight file support

Data Importers:

• omni.cae.asset_importer.*: Import various file formats into a USD stage

Advanced Processing:

• omni.cae.index: Volume rendering with IndeX
• omni.cae.flow: Flow-based fluid simulation
• omni.cae.algorithms.warp: NVIDIA Warp-based algorithms

Build Steps Executed

1. ./repo.sh schema: Build USD schemas
   • Compiles new USD prim types for CAE data
   • Builds schema definitions under usdSchema/
2. ./repo.sh build -r: Build Omniverse extensions
   • Compiles all CAE extensions in release mode
   • Builds C++ plugins and Python extensions
3. ./repo.sh launch -n omni.cae.kit: Launch the application
   • Starts the default CAE editor (version without VTK)
   • Loads all required extensions

Additional Features

Run the VTK-enabled variant:

./repo.sh launch -n omni.cae_vtk.kit


Run a sample script:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-bounding-box.py


Supported Data Formats

• CGNS (.cgns): CFD standard
• VTK (.vtk, .vti, .vtu): Visualization Toolkit formats
• EnSight (.case): EnSight Gold format
• NumPy (.npz, .npy): Point cloud / array data

This project provides a complete framework for efficiently processing and visualizing scientific simulation data within the Omniverse ecosystem.

2. Basic Setup

Prerequisites

1. Install Git LFS and download large data

sudo apt install git-lfs
git lfs install
git lfs pull


1. Download VTK packages (for VTK examples)

mkdir -p pip_archives
./repo.sh pip_download --dest pip_archives -r ./tools/deps/requirements.txt


Complete Example Matrix

Categorized by Tech Stack

Command Summary

Core Examples (12)

./repo.sh launch -n omni.cae.kit -- --exec scripts/[예제명].py


VTK Examples (2)

# VTK 설정 (최초 1회)
mkdir -p pip_archives
./repo.sh pip_download --dest pip_archives -r ./tools/deps/requirements.txt

# 실행
./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/[예제명].py


3. Kit-CAE Example Guide

This document systematically analyzes all Kit-CAE example scripts and summarizes their outputs.

Example Overview

Kit-CAE provides 14 example scripts, categorized as follows:

Supported by the core Kit-CAE app (omni.cae.kit, 12 examples)

• Geometric Analysis: bounding-box, faces, points, glyphs
• IndeX Rendering: slice, volume, nvdb-slice, slice-on-volume, nvdb-slice-on-volume
• NumPy Data: npz, npz-point-cloud
• Flow Simulation: npz-volume-streamlines

Requires the VTK build (omni.cae_vtk.kit, 2 examples)

• VTK File Handling: headsq-vti
• VTK Streamlines: streamlines

By Advanced Feature

• NanoVDB Optimization: nvdb-slice, nvdb-slice-on-volume, npz-point-cloud, headsq-vti
• Volume-based Slicing: slice-on-volume, nvdb-slice-on-volume
• Dynamic Simulation: npz-volume-streamlines (Flow + Timeline)
• Multi-dataset: bounding-box (integrates 2 datasets)

Runnable with the core Kit-CAE (omni.cae.kit):
✅ example-bounding-box.py
✅ example-faces.py
✅ example-glyphs.py
✅ example-points.py
✅ example-npz.py
✅ example-slice.py
✅ example-volume.py
✅ example-npz-point-cloud.py

Requires the VTK variant (omni.cae_vtk.kit):
✅ example-headsq-vti.py (VTK 임포터 필요)
✅ example-streamlines.py (VTK 스트림라인)

Flow/NanoVDB advanced examples:
✅ example-npz-volume-streamlines.py (Flow 기반 볼륨 스트림라인)
✅ example-nvdb-slice.py (NanoVDB 슬라이스)
✅ example-nvdb-slice-on-volume.py (NanoVDB 볼륨 슬라이스)
✅ example-slice-on-volume.py (IndeX 볼륨 슬라이스)

Geometric Analysis

1. example-bounding-box.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-bounding-box.py

Analysis:

• Purpose: Extract and visualize spatial extents (AABB) of CAE grid data
• Data: Multiple grid zones in StaticMixer.cgns
  • GridCoordinates: Node coordinates for the entire computational domain (CoordinateX/Y/Z)
  • in1, in2: Inlet boundary zones

Physical Context:

• CGNS coordinates: 3D Cartesian (X, Y, Z) [m]
• Grid topology: Min/max coordinates for unstructured grids
• Boundary zones: Geometric areas where inlet BCs apply

Key Code:

# 1) Single-dataset bounding box (whole domain)
dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/GridCoordinates"
viz_path = "/World/CAE/BoundingBox_GridCoordinates"
omni.kit.commands.execute("CreateCaeAlgorithmsExtractBoundingBox",
dataset_paths=[dataset_path], prim_path=viz_path)

# 2) Combined bounding box for multiple datasets (inlets)
dataset_paths = [
"/World/StaticMixer_cgns/Base/StaticMixer/in1",
"/World/StaticMixer_cgns/Base/StaticMixer/in2"
]
viz_path2 = "/World/CAE/BoundingBox_Inlets"
omni.kit.commands.execute("CreateCaeAlgorithmsExtractBoundingBox",
dataset_paths=dataset_paths, prim_path=viz_path2)

# 3) Auto frame the camera (whole domain)
omni.kit.commands.execute("FrameSelection", prim_paths=[viz_path], zoom=0.8)


Technical Highlights:

• AABB: Axis-wise min/max box generation
• Multi-zone merge: Combined extents across grid blocks
• Coord transform: CGNS → USD world mapping
• Visual: Wireframe boxes to show spatial bounds

Research Uses: Domain size validation, grid quality checks, BC location verification, spatial relationships across multi-physics regions

2. example-faces.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-faces.py

Analysis:

• Purpose: Extract external faces from a 3D volume mesh to visualize the surface shape
• Data: B1_P3 zone in StaticMixer.cgns (3D unstructured volume)
• Physical Context:
  • B1_P3: MIXED element types (tet/hex/prism/pyramid)
  • External faces: Faces without adjacent cells (∂Ω)
  • Surface extraction: Generate 2D faces from volume topology

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/B1_P3"
viz_path = "/World/CAE/ExternalFaces_B1_P3"
omni.kit.commands.execute("CreateCaeAlgorithmsExtractExternalFaces",
dataset_path=dataset_path, prim_path=viz_path)

omni.kit.commands.execute("FrameSelection", prim_paths=[viz_path], zoom=0.05)


Technical Highlights:

• Face extraction: Identify non-shared faces of volume elements
• Topology conversion: 3D → 2D triangles/quads
• Normals: Outward unit normals
• Surface mesh: Continuous 2D manifold

Research Uses: Wall-BC visualization, surface roughness, heat-transfer area, pressure mapping, shape-optimization checks

3. example-points.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-points.py

Analysis:

• Purpose: Visualize 3D grid nodes as a point cloud and analyze scalar fields
• Data: GridCoordinates in StaticMixer.cgns
• Physical Context:
  • GridCoordinates: Standard CGNS node arrays (CoordinateX/Y/Z)
  • Vertex-centered data: Physical quantities at nodes
  • Temperature field: T(x,y,z) [K]
  • Point rendering: Each grid node rendered as a 3D point

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/GridCoordinates"
viz_path = "/World/CAE/Points_GridCoordinates"
omni.kit.commands.execute("CreateCaeAlgorithmsExtractPoints",
dataset_path=dataset_path, prim_path=viz_path)

viz_prim = stage.GetPrimAtPath(viz_path)
viz_prim.GetAttribute("omni:cae:algorithms:points:width").Set(0.25)

viz_prim.GetRelationship("omni:cae:algorithms:points:colors").SetTargets(
["/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/Temperature"]
)

omni.kit.commands.execute("FrameSelection", prim_paths=[viz_path])


Technical Highlights:

• Point density vs grid resolution
• Scalar colormap (e.g., viridis/plasma)
• GPU point-sprite rendering
• Node–cell interpolation relationships

Research Uses: Grid quality (uniformity), temperature gradients, adaptivity checks, numerical diffusion patterns, convergence studies

Vector-Field Visualization

4. example-glyphs.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-glyphs.py

Analysis:

• Purpose: Visualize direction and magnitude of a 3D vector field using arrow glyphs
• Data: B1_P3 in StaticMixer.cgns

Physical Context:

• B1_P3: 3D unstructured grid with MIXED elements
• Flow_Solution: Cell-centered results
• Velocity vector: (VelocityX, VelocityY, VelocityZ) [m/s]
• Temperature scalar: Temperature [K]

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/B1_P3"
viz_path = "/World/CAE/Glpyhs_B1_P3"
omni.kit.commands.execute("CreateCaeAlgorithmsGlyphs",
dataset_path=dataset_path, prim_path=viz_path)

arrow_path = viz_path + "/Protos/ArrowXform"
arrow_prim = stage.GetPrimAtPath(arrow_path)
UsdGeom.XformCommonAPI(arrow_prim).SetScale((0.1, 0.1, 0.1))

viz_prim.GetRelationship("omni:cae:algorithms:glyphs:orientation").SetTargets([
"/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/VelocityX",
"/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/VelocityY",
"/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/VelocityZ"
])

viz_prim.GetRelationship("omni:cae:algorithms:glyphs:colors").SetTargets(
["/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/Temperature"]
)


Technical Highlights:

• Glyph density and scaling
• Direction fidelity with normalized velocity
• Color encoding by temperature
• Visual decluttering via scale tuning

Research Uses: Velocity–temperature correlation, mixing efficiency, heat-transfer visualization, vortex ID

Advanced Rendering (IndeX)

5. example-slice.py

실Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-slice.py


Analysis:

• Purpose: High-performance 2D slicing of 3D scalar fields using NVIDIA IndeX
• Data: B1_P3 in StaticMixer.cgns
• Physical Context:
  • Eddy Viscosity (μₜ) [Pa·s]
  • IndeX rendering: GPU-accelerated volume engine
  • Cutting plane: Arbitrary orientation
  • Interactive: Live slice pose editing

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/B1_P3"
slice_path = "/World/CAE/IndeXSlice_B1_P3"
omni.kit.commands.execute("CreateCaeIndeXSlice",
dataset_path=dataset_path, prim_path=slice_path)

slice_prim = stage.GetPrimAtPath(slice_path)
slice_prim.GetRelationship("omni:cae:index:slice:field").SetTargets(
["/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/Eddy_Viscosity"]
)

for i in range(10):
await asyncio.sleep(0.1)
await omni.kit.app.get_app().next_update_async()


Technical Highlights: GPU acceleration, adaptive sampling, live colormaps, memory efficiency

Research Uses: Turbulence structure, mixing layer, shear stress, separation zones, turbulence-model validation

6. example-volume.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-volume.py

Analysis:

• Purpose: 3D volume rendering of scalar fields with NVIDIA IndeX
• Data: B1_P3 in StaticMixer.cgns

Physical Context: Volume rendering, transfer functions, ray-marching, μₜ distribution

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/B1_P3"
viz_path = "/World/CAE/IndeXVolume_B1_P3"
omni.kit.commands.execute("CreateCaeIndeXVolume",
dataset_path=dataset_path, prim_path=viz_path)

viz_prim = stage.GetPrimAtPath(viz_path)
viz_prim.GetRelationship("omni:cae:index:volume:field").SetTargets(
["/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution/Eddy_Viscosity"]
)

omni.kit.commands.execute("FrameSelection", prim_paths=[viz_path])


Technical Highlights: Ray casting, adaptive sampling, transfer-function tuning, LOD

Research Uses: 3D turbulence structure, vortex cores, mixing quantification, volumetric patterns

By Data Format

7. example-npz.py

Run:

./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/example-npz.py

Analysis:

• Purpose: Generate 3D streamlines from NumPy (.npz) for flow/thermal analysis
• Data: disk_out_ref.npz (flow around a rotating disk)

Physical Context: NPZ arrays, SIDS Unstructured mapping, streamlines, Lagrangian tracking

Key Code:

# 1. NPZ 파일을 USD 스키마로 변환
async def npz_to_usd(npz_path: str, mesh_schema_type):
importer = NPZAssetImporter()
importer._options_builder.get_import_context().mesh_schema_type = mesh_schema_type
out = await importer.convert_assets([npz_path], import_as_reference=True)
return next(iter(out.values()))

usd_path = await npz_to_usd(npz_path=npz_path, mesh_schema_type="SIDS Unstructured")

# 2. 필드 연관성 설정 (vertex-centered 데이터)
array_paths = ["/World/disk_out_ref_npz/NumPyArrays/V",
"/World/disk_out_ref_npz/NumPyArrays/Temp"]
for array_path in array_paths:
array_prim = stage.GetPrimAtPath(array_path)
array_prim.GetAttribute("fieldAssociation").Set("vertex")

# 3. 스트림라인 알고리즘 생성
dataset_path = "/World/disk_out_ref_npz"
viz_path = "/World/CAE/Streamlines_disk_out_ref_npz"
omni.kit.commands.execute("CreateCaeStreamlines",
dataset_path=dataset_path, prim_path=viz_path)

# 4. 구형 시드 영역 설정
sphere_path = "/World/CAE/StreamlineSeed"
omni.kit.commands.execute("CreateMeshPrim", prim_type="Sphere", prim_path=sphere_path)
UsdGeom.XformCommonAPI(sphere_prim).SetScale((0.01, 0.01, 0.01))

# 5. 속도 벡터 및 색상 매핑
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:seeds").SetTargets([sphere_path])
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:velocity").SetTargets(
["/World/disk_out_ref_npz/NumPyArrays/V"]
)
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:colors").SetTargets(
["/World/disk_out_ref_npz/NumPyArrays/Temp"]
)


Technical Highlights: NumPy→SIDS→USD conversion, RK4 integration, spherical seeding, color interpolation

Research Uses: Rotating machinery, heat-transfer paths, Python simulation validation, qualitative flow analysis

8. example-npz-point-cloud.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-npz-point-cloud.py

Analysis:

• Purpose: Voxelize sparse point data into a NanoVDB volume for continuous-field visualization
• Data: disk_out_ref.npz (converted to Point Cloud schema)

Physical Context: Point clouds, NanoVDB, voxelization (Gaussian splatting), temperature field

Key Code:

async def npz_to_usd(npz_path: str, mesh_schema_type):
importer = NPZAssetImporter()
importer._options_builder.get_import_context().mesh_schema_type = mesh_schema_type
out = await importer.convert_assets([npz_path], import_as_reference=True)
return next(iter(out.values()))

usd_path = await npz_to_usd(npz_path=npz_path, mesh_schema_type="Point Cloud")

dataset_path = "/World/disk_out_ref_npz"
viz_path = "/World/CAE/NanoVdbIndeXVolume_disk_out_ref_npz"
omni.kit.commands.execute("CreateCaeNanoVdbIndeXVolume",
dataset_path=dataset_path, prim_path=viz_path)

viz_prim = stage.GetPrimAtPath(viz_path)
viz_prim.GetRelationship("omni:cae:index:nvdb:field").SetTargets(
["/World/disk_out_ref_npz/NumPyArrays/Temp"])

colormap_prim = stage.GetPrimAtPath(viz_path + "/Material/Colormap")
colormap_prim.GetAttribute("domain").Set(Gf.Vec2f(0.0, 100.0))


Technical Highlights: Gaussian splatting, sparse volumes, GPU voxelization, adaptive resolution

Research Uses: Lagrangian particle analyses, sparse measurement viz, MD post-processing, reconstructing continuous fields

VTK-based Examples

Note: The following require VTK and must run under omni.cae_vtk.kit.

Verify VTK Setup

ls -la pip_archives/
# Expect: vtk-9.4.0-...whl (~105MB)

9. example-headsq-vti.py (Requires VTK)

Run:

# First-time VTK package download
mkdir -p pip_archives
./repo.sh pip_download --dest pip_archives -r ./tools/deps/requirements.txt

# Launch VTK-enabled app
./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/example-headsq-vti.py


Analysis:

• Purpose: Convert VTK structured image (.vti) to NanoVDB and render with ROI
• Data: headsq.vti (medical imaging, 3D structured grid)

Physical Context: VTI (VTK ImageData), CT/MRI intensity, ROI selection, structured grids

Key Code:

async def vti_to_usd(vti_path: str):
importer = VTKImporter()
out = await importer.convert_assets([vti_path], import_as_reference=True)
return next(iter(out.values()))

usd_path = await vti_to_usd(vti_path=vti_path)

dataset_path = "/World/headsq_vti"
viz_path = "/World/CAE/NanoVdbIndeXVolume_headsq_vti"
omni.kit.commands.execute("CreateCaeNanoVdbIndeXVolume",
dataset_path=dataset_path, prim_path=viz_path)

viz_prim = stage.GetPrimAtPath(viz_path)
viz_prim.GetRelationship("omni:cae:index:nvdb:field").SetTargets(
["/World/headsq_vti/PointData/Scalars_"])

bbox_path = "/World/CAE/BoundingBox_headsq_vti"
omni.kit.commands.execute("CreateCaeAlgorithmsExtractBoundingBox",
dataset_paths=[dataset_path], prim_path=bbox_path)

UsdGeom.XformCommonAPI(stage.GetPrimAtPath(bbox_path)).SetScale((0.5, 1.0, 1.0))
viz_prim.GetRelationship("omni:cae:index:nvdb:roi").SetTargets([bbox_path])


Technical Highlights: Structured-grid handling, ROI clipping, medical transfer functions, memory efficiency

Research Uses: CT/MRI diagnostics, bio-tissue modeling, structured-grid CFD, ROI-focused analysis

10. example-streamlines.py (Requires VTK)

Run:

./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/example-streamlines.py

Analysis:

• Purpose: High-accuracy streamlines using VTK’s advanced integrators
• Data: B1_P3 in StaticMixer.cgns

Physical Context: VTK streamlines (RK4/RK45), adaptive step sizes, high-precision interpolation, smooth streamlines

Key Code:

dataset_path = "/World/StaticMixer_cgns/Base/StaticMixer/B1_P3"
viz_path = "/World/CAE/Streamlines_B1_P3"
omni.kit.commands.execute("CreateCaeStreamlines",
dataset_path=dataset_path, prim_path=viz_path)

sphere_path = "/World/CAE/StreamlineSeed"
omni.kit.commands.execute("CreateMeshPrim", prim_type="Sphere", prim_path=sphere_path)
UsdGeom.XformCommonAPI(stage.GetPrimAtPath(sphere_path)).SetScale((0.01, 0.01, 0.01))

viz_prim = stage.GetPrimAtPath(viz_path)
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:seeds").SetTargets([sphere_path])

flow = "/World/StaticMixer_cgns/Base/StaticMixer/Flow_Solution"
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:velocity").SetTargets(
[f"{flow}/VelocityX", f"{flow}/VelocityY", f"{flow}/VelocityZ"])
viz_prim.GetRelationship("omni:cae:algorithms:streamlines:colors").SetTargets(
[f"{flow}/Temperature"])


Technical Highlights: RK4/5 integrators, adaptive steps, precise cell-point interpolation, smooth curves

Research Uses: Precision CFD, vortex quantification, mixing efficiency, turbomachinery validation, turbulence statistics

Flow/NanoVDB Advanced

11. example-npz-volume-streamlines.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-npz-volume-streamlines.py

Analysis:

• Purpose: Flow-driven volume streamlines
• Data: disk_out_ref.npz (SIDS Unstructured)

Features:

• Build a Flow environment with CreateCaeFlowEnvironment + CreateCaeFlowSmoker
• Set a dataset emitter via CreateCaeFlowDataSetEmitter
• Connect velocity V and set velocityScale=2.0
• Auto-play timeline for real-time animation

Use Cases: Dynamic flow visualization, real-time particle tracking, volume-based flow analysis

Code Notes (Path Wiring):

# Step 1: Field association → vertex
array_base_path = "/World/disk_out_ref_npz/NumPyArrays"
for name in ["AsH3", "CH4", "GaMe3", "H2", "Pres", "Temp", "V"]:
stage.GetPrimAtPath(f"{array_base_path}/{name}").GetAttribute("fieldAssociation").Set("vertex")

# Step 2: Flow dataset and velocity targets
dataset_path = "/World/disk_out_ref_npz/NumPyDataSet"
velocity_target = "/World/disk_out_ref_npz/NumPyArrays/V"

12. example-nvdb-slice.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-nvdb-slice.py


Analysis:

• Purpose: High-efficiency slicing with NanoVDB
• Data: B1_P3 in StaticMixer.cgns
• Features: CreateCaeIndeXNanoVdbSlice, Eddy_Viscosity NVDB field, memory-efficient processing, async stage updates

Use Cases: Efficient slicing of large data, real-time cross-sections, GPU memory optimization

13. example-nvdb-slice-on-volume.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-nvdb-slice-on-volume.py

Analysis:

• Purpose: Overlay slices on a NanoVDB volume
• Data: B1_P3 in StaticMixer.cgns
• Features: CreateCaeNanoVdbIndeXVolume (hidden base), CreateCaeIndeXVolumeSlice, Eddy_Viscosity mapping, maxResolution=64 perf cap

Use Cases: Selective visualization, perf/quality tuning, composite workflows

14. example-slice-on-volume.py

Run:

./repo.sh launch -n omni.cae.kit -- --exec scripts/example-slice-on-volume.py

Analysis:

• Purpose: IndeX volume-based slicing
• Data: B1_P3 in StaticMixer.cgns
• Features: CreateCaeIndeXVolume (hidden base), CreateCaeIndeXVolumeSlice, Eddy_Viscosity mapping, automatic colormap/range inheritance

Use Cases: Consistent volume+slice visualization, automatic colormaps, standard IndeX workflow

Quick-Run Reference

Core Examples (omni.cae.kit)

# Geometric analysis
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-bounding-box.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-faces.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-points.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-glyphs.py

# IndeX rendering
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-slice.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-volume.py

# NumPy data
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-npz.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-npz-point-cloud.py

# Flow/NanoVDB advanced
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-npz-volume-streamlines.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-nvdb-slice.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-nvdb-slice-on-volume.py
./repo.sh launch -n omni.cae.kit -- --exec scripts/example-slice-on-volume.py


VTK Examples (omni.cae_vtk.kit)

# VTK packages (first time)
mkdir -p pip_archives
./repo.sh pip_download --dest pip_archives -r ./tools/deps/requirements.txt

# Run VTK examples
./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/example-headsq-vti.py
./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/example-streamlines.py


Troubleshooting

Git LFS Issues

Symptom: CGNS file detected as ASCII text

file StaticMixer.cgns
# Wrong: ASCII text


Fix:

sudo apt install git-lfs
git lfs install
git lfs pull


Verify:

file StaticMixer.cgns
# Correct: Hierarchical Data Format (version 5) data


VTK Dependency Issues

Symptom: ModuleNotFoundError: No module named 'vtkmodules'

Fix:

./repo.sh pip_download --dest pip_archives -r ./tools/deps/requirements.txt
./repo.sh launch -n omni.cae_vtk.kit -- --/exts/omni.kit.pipapi/archiveDirs=[pip_archives] --exec scripts/[example].py


Common Runtime Errors

1. Stage is None: Wait for file load to complete
2. Invalid prim paths: Check USD stage structure
3. Out of memory: For large datasets, verify system resources

Performance Tuning Tips

1. Large datasets: Prefer IndeX-based rendering
2. Interactive workflows: Use slices and ROIs
3. Memory management: Unload unused datasets
4. GPU acceleration: Ensure CUDA support

Conclusion

The full set of 14 Kit-CAE examples delivers a complete CAE visualization workflow:

Summary by Category

Geometric Analysis (4)

• Bounding Box – Visualize data extents
• External Faces – Extract/render surfaces
• Points – Point-cloud visualization
• Glyphs – Vector-field arrows

Advanced Rendering (6)

• IndeX Slice/Volume – Core slicing & volume rendering
• NanoVDB – GPU-optimized sparse volumes
• Volume-based Slicing – Slice over volumes
• Flow Streamlines – Dynamic animations

Data Format Support (4)

• CGNS – CFD standard (used in 8 examples)
• NPZ – NumPy arrays (3 examples)
• VTI – VTK image (1 example)

Core Tech Stack

• USD Schemas, IndeX, NanoVDB, Flow, VTK, Warp

Completeness Check

All 14 examples run successfully, confirming Kit-CAE as a comprehensive CAE visualization solution offering:

• Broad capability from basic analysis to advanced rendering
• Wide data support across major CAE formats
• Extensibility for new algorithms/data models
• Real-time performance via GPU optimization
• Usability through intuitive APIs and automated setup