Recreate Trame_app branch with clean history

.dockerignore

@@ -0,0 +1,69 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+
+# IDEs
+.vscode
+.idea
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.bak
+
+# Large data files (if any)
+*.h5
+*.hdf5
+*.pkl
+*.pickle
+*.npz
+*.npy
+
+# Documentation
+README.md
+docs/
+*.md
+
+# Test files
+test_*
+*_test.py
+tests/

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/hf_sync.yml

@@ -0,0 +1,27 @@
+name: Sync to Hugging Face Space
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Git
+        run: |
+          git config --global user.email "[email protected]"
+          git config --global user.name "Navaneeth"
+      
+      - name: Push to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git remote add space https://user:${HF_TOKEN}@huggingface.co/spaces/ansysresearch/AnsysLPFM-App
+
+
+          git push --force space main

.github/workflows/run_test.yml

@@ -0,0 +1,32 @@
+name: Run PyTest on Push to Main
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          # Optional: if you use Hydra, OmegaConf, or HDBSCAN etc.
+          pip install pytest omegaconf hdbscan scikit-learn torch
+
+      - name: Run tests
+        run: |
+          export PYTHONPATH=$PYTHONPATH:$(pwd)
+          pytest -v --maxfail=1 --disable-warnings

.gitignore

@@ -0,0 +1,80 @@
+# VSCode settings
+.vscode/
+
+# Data folders
+Data/
+# metrics/
+# Python cache
+__pycache__/
+**/__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Python cache in specific directories
+utils/*.pyc
+utils/__pycache__/
+trainers/*.pyc
+trainers/__pycache__/
+models/*.pyc
+models/__pycache__/
+datasets/*.pyc
+datasets/__pycache__/
+datasets/*/*.pyc
+datasets/*/__pycache__/
+postprocessing.py
+*.mp4
+*.stl
+*.png
+*.mp4
+*.stl
+*.png
+datasets/artery/*.pyc
+datasets/artery/__pycache__/
+datasets/elasticity/*.pyc
+datasets/elasticity/__pycache__/
+datasets/DrivAerML/*.pyc
+datasets/DrivAerML/__pycache__/
+datasets/plane/*.pyc
+datasets/plane/__pycache__/
+datasets/deepjeb/*.pyc
+datasets/deepjeb/__pycache__/
+datasets/driveaerpp/*.pyc
+datasets/driveaerpp/__pycache__/
+datasets/shapenet_car_pv/*.pyc
+datasets/shapenet_car_pv/__pycache__/
+datasets/DriveAerNet/*.pyc
+datasets/DriveAerNet/__pycache__/
+
+# TensorBoard logs
+tensorboard_logs/
+log_files
+Dockerfile
+.dockerignore
+
+__pycache__/
+**/__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Output files
+out_trans_driveraerml.out
+*.log
+# Ignore all __pycache__ in subfolders
+datasets/DrivAerML/__pycache__/
+datasets/DriveAerNet/__pycache__/
+datasets/elasticity/__pycache__/
+datasets/shapenet_car_pv/__pycache__/
+models/__pycache__/
+trainers/__pycache__/
+
+
+# umap
+*.png
+similarity/
+*.vtk
+*.npy
+
+# Ignore all experiment metrics and checkpoints
+metrics/*

Dockerfile

@@ -0,0 +1,70 @@
+
+
+# Use NVIDIA CUDA base image (Ubuntu 22.04 jammy)
+FROM nvidia/cuda:12.3.2-devel-ubuntu22.04
+
+# Non-interactive apt
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV CUDA_HOME=/usr/local/cuda
+ENV PATH=${CUDA_HOME}/bin:/usr/local/bin:${PATH}
+ENV LD_LIBRARY_PATH=${CUDA_HOME}/lib64:${LD_LIBRARY_PATH}
+
+# System deps + Deadsnakes PPA for Python 3.12
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    software-properties-common \
+    ca-certificates \
+    curl wget git build-essential \
+    libgl1-mesa-glx libglib2.0-0 libsm6 libxext6 libxrender1 \
+    libgomp1 libgcc-s1 \
+ && add-apt-repository ppa:deadsnakes/ppa -y \
+ && apt-get update && apt-get install -y --no-install-recommends \
+    python3.12 python3.12-dev python3.12-venv \
+ && rm -rf /var/lib/apt/lists/*
+
+# Install pip for Python 3.12
+RUN curl -sS https://bootstrap.pypa.io/get-pip.py -o /tmp/get-pip.py \
+ && python3.12 /tmp/get-pip.py \
+ && rm /tmp/get-pip.py
+
+# Make 'python' and 'pip' point to 3.12
+RUN ln -sf /usr/bin/python3.12 /usr/bin/python && \
+    ln -sf /usr/local/bin/pip3.12 /usr/local/bin/pip
+
+# ---------------- Writable app data & HF cache ----------------
+ENV APP_DATA_DIR=/data
+ENV HF_HOME=/data/hf_home
+ENV HUGGINGFACE_HUB_CACHE=/data/hf_home
+ENV TRANSFORMERS_CACHE=/data/hf_home
+ENV MPLCONFIGDIR=/data/matplotlib   
+
+RUN mkdir -p /data/geometry /data/solution /data/weights /data/hf_home /data/matplotlib \
+ && chmod -R 777 /data
+
+# ---------------- Install frpc for Gradio share=True ----------------
+RUN mkdir -p /data/hf_home/gradio/frpc && \
+    wget https://cdn-media.huggingface.co/frpc-gradio-0.3/frpc_linux_amd64 -O /data/hf_home/gradio/frpc/frpc_linux_amd64_v0.3 && \
+    chmod +x /data/hf_home/gradio/frpc/frpc_linux_amd64_v0.3
+
+# ---------------- Application setup ----------------
+WORKDIR /app
+
+# Copy requirements first (better caching)
+COPY requirements.txt .
+
+# Install Python deps
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel \
+ && pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the source
+COPY . .
+
+# Permissions
+RUN chmod +x app.py
+RUN chown -R 1000:1000 /app
+
+# Expose Gradio port
+EXPOSE 7860
+
+# Run app
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Main_app_trame.py

@@ -0,0 +1,1701 @@
+# ========= Headless / Offscreen safety (before any VTK import) =========
+import os
+os.environ.setdefault("VTK_DEFAULT_RENDER_WINDOW_OFFSCREEN", "1")
+os.environ.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+os.environ.setdefault("MESA_LOADER_DRIVER_OVERRIDE", "llvmpipe")
+os.environ.setdefault("MESA_GL_VERSION_OVERRIDE", "3.3")
+os.environ.setdefault("DISPLAY", "")
+
+# ========= Core setup =========
+import shutil, time, tempfile, json, base64, threading, re, html as _html, asyncio
+import numpy as np
+import torch
+import pyvista as pv
+from scipy.spatial import cKDTree
+from vtk.util import numpy_support as nps
+import matplotlib.cm as cm
+
+from omegaconf import OmegaConf
+from huggingface_hub import hf_hub_download
+from accelerate import Accelerator
+from accelerate.utils import DistributedDataParallelKwargs
+import pickle
+from sklearn.metrics import pairwise_distances
+from train import get_single_latent
+from sklearn.neighbors import NearestNeighbors
+
+from utils.app_utils2 import (
+    create_visualization_points,
+    create_visualization_stl,
+    camera_from_bounds,
+    bounds_from_points,
+    convert_vtp_to_glb,
+    convert_vtp_to_stl,
+    time_function,
+    print_timing,
+    mesh_get_variable,
+    mph_to_ms,
+    get_boundary_conditions_text,
+    compute_confidence_score,
+    compute_cosine_score,
+    decimate_mesh,
+)
+
+# ========= trame =========
+from trame.app import TrameApp
+from trame.decorators import change
+from trame.ui.vuetify3 import SinglePageLayout
+from trame.widgets import vuetify3 as v3, html
+from trame_vtk.widgets.vtk import VtkRemoteView
+
+# ========= VTK =========
+from vtkmodules.vtkRenderingCore import (
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkPolyDataMapper,
+    vtkActor,
+    vtkRenderWindowInteractor,
+)
+from vtkmodules.vtkRenderingAnnotation import vtkScalarBarActor
+from vtkmodules.vtkIOGeometry import vtkSTLReader
+from vtkmodules.vtkFiltersCore import vtkTriangleFilter
+from vtkmodules.vtkCommonCore import vtkLookupTable
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+
+# ========= Writable paths / caches =========
+DATA_DIR = os.path.join(tempfile.gettempdir(), "appdata")
+os.makedirs(DATA_DIR, exist_ok=True)
+os.environ.setdefault("MPLCONFIGDIR", DATA_DIR)
+
+GEOM_DIR = os.path.join(DATA_DIR, "geometry")
+SOLN_DIR = os.path.join(DATA_DIR, "solution")
+WEIGHTS_DIR = os.path.join(DATA_DIR, "weights")
+for d in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR):
+    os.makedirs(d, exist_ok=True)
+
+HF_DIR = os.path.join(DATA_DIR, "hf_home")
+os.environ.setdefault("HF_HOME", HF_DIR)
+os.environ.setdefault("HUGGINGFACE_HUB_CACHE", HF_DIR)
+os.environ.setdefault("TRANSFORMERS_CACHE", HF_DIR)
+os.makedirs(HF_DIR, exist_ok=True)
+for p in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR, HF_DIR):
+    if not os.access(p, os.W_OK):
+        raise RuntimeError(f"Not writable: {p}")
+
+# ========= Auto-decimation ladder =========
+def auto_target_reduction(num_cells: int) -> float:
+    if num_cells <= 10_000:
+        return 0.0
+    elif num_cells <= 20_000:
+        return 0.2
+    elif num_cells <= 50_000:
+        return 0.4
+    elif num_cells <= 100_000:
+        return 0.5
+    elif num_cells <= 500_000:
+        return 0.6
+    elif num_cells < 1_000_000:
+        return 0.8
+    else:
+        return 0.9
+
+# ========= Registry / choices =========
+REGISTRY = {
+    "Incompressible flow inside artery": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow inside artery/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_artery.pt"},
+        "out_variable": ["pressure", "x_velocity", "y_velocity", "z_velocity"],
+    },
+    "Vehicle crash analysis": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Vehicle crash analysis/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_vehiclecrash.pt"},
+        "out_variable": [
+            "impact_force",
+            "deformation",
+            "energy_absorption",
+            "x_displacement",
+            "y_displacement",
+            "z_displacement",
+        ],
+    },
+    "Compressible flow over plane": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Compressible flow over plane/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_plane_transonic_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+    "Incompressible flow over car": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow over car/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_cadillac_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+}
+
+def variables_for(dataset: str):
+    spec = REGISTRY.get(dataset, {})
+    ov = spec.get("out_variable")
+    if isinstance(ov, str):
+        return [ov]
+    if isinstance(ov, (list, tuple)):
+        return list(ov)
+    return list(spec.get("checkpoints", {}).keys())
+
+ANALYSIS_TYPE_MAPPING = {
+    "External flow": ["Incompressible flow over car", "Compressible flow over plane"],
+    "Internal flow": ["Incompressible flow inside artery"],
+    "Crash analysis": ["Vehicle crash analysis"],
+}
+ANALYSIS_TYPE = list(ANALYSIS_TYPE_MAPPING.keys())
+DEFAULT_ANALYSIS_TYPE = "External flow"
+DEFAULT_DATASET = "Incompressible flow over car"
+VAR_CHOICES0 = variables_for(DEFAULT_DATASET)
+DEFAULT_VARIABLE = VAR_CHOICES0[0] if VAR_CHOICES0 else None
+
+# ========= Simple cache =========
+class GeometryCache:
+    def __init__(self):
+        self.original_mesh = None   # uploaded, cleaned (normals), BEFORE user re-decimation
+        self.current_mesh = None    # what the app is actually using right now
+
+GEOMETRY_CACHE = GeometryCache()
+
+# ========= Model store =========
+class ModelStore:
+    def __init__(self):
+        self._cache = {}
+
+    def _build(self, dataset: str, progress_cb=None):
+        def tick(x):
+            if progress_cb:
+                try:
+                    progress_cb(int(x))
+                except:
+                    pass
+
+        if dataset in self._cache:
+            tick(12)
+            return self._cache[dataset]
+
+        print(f"🔧 Building model for {dataset}")
+        start_time = time.time()
+        try:
+            spec = REGISTRY[dataset]
+            repo_id = spec["repo_id"]
+            ckpt_name = spec["checkpoints"]["best_val"]
+
+            tick(6)
+            t0 = time.time()
+            ckpt_path_hf = hf_hub_download(
+                repo_id=repo_id,
+                filename=ckpt_name,
+                repo_type="model",
+                local_dir=HF_DIR,
+                local_dir_use_symlinks=False,
+            )
+            print_timing("Model checkpoint download", t0)
+            tick(8)
+
+            t0 = time.time()
+            ckpt_local_dir = os.path.join(WEIGHTS_DIR, dataset)
+            os.makedirs(ckpt_local_dir, exist_ok=True)
+            ckpt_path = os.path.join(ckpt_local_dir, ckpt_name)
+            if not os.path.exists(ckpt_path):
+                shutil.copy(ckpt_path_hf, ckpt_path)
+            print_timing("Local model copy setup", t0)
+            tick(9)
+
+            t0 = time.time()
+            cfg_path = spec["config"]
+            if not os.path.exists(cfg_path):
+                raise FileNotFoundError(f"Missing config: {cfg_path}")
+            cfg = OmegaConf.load(cfg_path)
+            cfg.save_latent = True
+            print_timing("Configuration loading", t0)
+            tick(11)
+
+            t0 = time.time()
+            os.environ["CUDA_VISIBLE_DEVICES"] = str(getattr(cfg, "gpu_id", 0))
+            ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+            accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            print_timing("Device init", t0)
+            tick(12)
+
+            t0 = time.time()
+            import models
+            model_cls_name = spec["model_attr"]
+            if not hasattr(models, model_cls_name):
+                raise ValueError(f"Model '{model_cls_name}' not found")
+            model = getattr(models, model_cls_name)(cfg).to(device)
+            print_timing("Model build", t0)
+            tick(14)
+
+            t0 = time.time()
+            state = torch.load(ckpt_path, map_location=device)
+            model.load_state_dict(state)
+            model.eval()
+            print_timing("Weights load", t0)
+            tick(15)
+
+            result = (cfg, model, device, accelerator)
+            self._cache[dataset] = result
+            print_timing(f"Total model build for {dataset}", start_time)
+            return result
+        except Exception as e:
+            print_timing(f"Model build failed for {dataset}", e)
+            raise RuntimeError(f"Failed to load model for dataset '{dataset}': {e}")
+
+    def get(self, dataset: str, variable: str, progress_cb=None):
+        return self._build(dataset, progress_cb=progress_cb)
+
+MODEL_STORE = ModelStore()
+
+# ========= Inference pipeline =========
+def _variable_index(dataset: str, variable: str) -> int:
+    ov = REGISTRY[dataset]["out_variable"]
+    return 0 if isinstance(ov, str) else ov.index(variable)
+
+@time_function("Mesh Processing")
+def process_mesh_fast(mesh: pv.DataSet, cfg, variable, dataset, boundary_conditions=None):
+    jpath = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+    json_data = json.load(open(jpath, "r"))
+
+    pts = np.asarray(mesh.points, dtype=np.float32)
+    N = pts.shape[0]
+    rng = np.random.default_rng(42)
+    idx = rng.permutation(N)
+    points = pts[idx]
+    tgt_np = mesh_get_variable(mesh, variable, N)[idx]
+    pos = torch.from_numpy(points)
+    target = torch.from_numpy(tgt_np).unsqueeze(-1)
+
+    if getattr(cfg, "diff_input_velocity", False) and boundary_conditions is not None:
+        if "freestream_velocity" in boundary_conditions:
+            inlet_x_velocity = torch.tensor(boundary_conditions["freestream_velocity"]).float().reshape(1, 1)
+            inlet_x_velocity = inlet_x_velocity.repeat(N, 1)[idx]
+            pos = torch.cat((pos, inlet_x_velocity), dim=1)
+
+    if getattr(cfg, "input_normalization", None) == "shift_axis":
+        coords = pos[:, :3].clone()
+        coords[:, 0] = coords[:, 0] - coords[:, 0].min()
+        coords[:, 2] = coords[:, 2] - coords[:, 2].min()
+        y_center = (coords[:, 1].max() + coords[:, 1].min()) / 2.0
+        coords[:, 1] = coords[:, 1] - y_center
+        pos[:, :3] = coords
+
+    if getattr(cfg, "pos_embed_sincos", False):
+        mins = torch.tensor(json_data["mesh_stats"]["min"], dtype=torch.float32)
+        maxs = torch.tensor(json_data["mesh_stats"]["max"], dtype=torch.float32)
+        pos = 1000.0 * (pos - mins) / (maxs - mins)
+        pos = torch.clamp(pos, 0, 1000)
+
+    cosine_score = compute_cosine_score(mesh, dataset)
+    return pos, target, points, cosine_score
+
+@time_function("Inference")
+def run_inference_fast(dataset: str, variable: str, boundary_conditions=None, progress_cb=None):
+    def p(v):
+        if progress_cb:
+            try:
+                progress_cb(int(v))
+            except Exception:
+                pass
+
+    if GEOMETRY_CACHE.current_mesh is None:
+        raise ValueError("No geometry loaded")
+
+    p(5)
+    cfg, model, device, _ = MODEL_STORE.get(dataset, variable, progress_cb=p)
+    p(15)
+
+    pos, target, points, cosine_score = process_mesh_fast(
+        GEOMETRY_CACHE.current_mesh, cfg, variable, dataset, boundary_conditions
+    )
+    p(25)
+
+    confidence_score = 0.0
+    try:
+        if dataset not in ["Incompressible flow inside artery"]:
+            geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+            latent_features = get_single_latent(
+                mesh_path=geom_path,
+                config_path=os.path.join("configs/app_configs/", dataset, "config.yaml"),
+                device=device,
+                custom_velocity=boundary_conditions["freestream_velocity"] if boundary_conditions else None,
+                use_training_velocity=False,
+                model=model,
+            )
+
+            embedding_path = os.path.join("configs/app_configs/", dataset, "pca_embedding.npy")
+            pca_reducer_path = os.path.join("configs/app_configs/", dataset, "pca_reducer.pkl")
+            scaler_path = os.path.join("configs/app_configs/", dataset, "pca_scaler.pkl")
+
+            embedding = np.load(embedding_path)
+            pca_reducer = pickle.load(open(pca_reducer_path, "rb"))
+            scaler = pickle.load(open(scaler_path, "rb"))
+
+            train_pair_dists = pairwise_distances(embedding)
+            sigma = float(np.median(train_pair_dists)) if train_pair_dists.size > 0 else 1.0
+
+            n_points, n_features = latent_features.shape
+            np.random.seed(42)
+            target_len = int(pca_reducer.n_features_in_ / 256)
+            if n_points > target_len:
+                latent_features = latent_features[np.random.choice(n_points, target_len, replace=False)]
+            elif n_points < target_len:
+                num_extra = target_len - n_points
+                extra_indices = np.random.choice(n_points, num_extra, replace=True)
+                latent_features = np.vstack([latent_features, latent_features[extra_indices]])
+
+            latent_features = latent_features.flatten()
+
+            confidence_score = compute_confidence_score(
+                latent_features, embedding, scaler, pca_reducer, sigma
+            )
+    except Exception:
+        confidence_score = 0.0
+
+    data = {
+        "input_pos": pos.unsqueeze(0).to(device),
+        "output_feat": target.unsqueeze(0).to(device),
+    }
+
+    with torch.no_grad():
+        inp = data["input_pos"]
+        _, N, _ = inp.shape
+        chunk = int(getattr(cfg, "num_points", 10000))
+
+        if getattr(cfg, "chunked_eval", False) and chunk < N:
+            input_pos = data["input_pos"]
+            chunk_size = cfg.num_points
+            out_chunks = []
+            total = (N + chunk_size - 1) // chunk_size
+
+            for k, i in enumerate(range(0, N, chunk_size)):
+                ch = input_pos[:, i : i + chunk_size, :]
+                n_valid = ch.shape[1]
+
+                if n_valid < chunk_size:
+                    pad = input_pos[:, : chunk_size - n_valid, :]
+                    ch = torch.cat([ch, pad], dim=1)
+
+                data["input_pos"] = ch
+                out_chunk = model(data)
+                if isinstance(out_chunk, (tuple, list)):
+                    out_chunk = out_chunk[0]
+                out_chunks.append(out_chunk[:, :n_valid, :])
+
+                p(25 + 60 * (k + 1) / max(1, total))
+
+            outputs = torch.cat(out_chunks, dim=1)
+
+        else:
+            p(40)
+            outputs = model(data)
+            if isinstance(outputs, (tuple, list)):
+                outputs = outputs[0]
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+            p(85)
+
+    vi = _variable_index(dataset, variable)
+    pred = outputs[0, :, vi : vi + 1]
+
+    if getattr(cfg, "normalization", "") == "std_norm":
+        fp = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+        j = json.load(open(fp, "r"))
+        mu = torch.tensor(float(j["scalars"][variable]["mean"]), device=pred.device)
+        sd = torch.tensor(float(j["scalars"][variable]["std"]), device=pred.device)
+        pred = pred * sd + mu
+
+    pred_np = pred.squeeze().detach().cpu().numpy()
+    tgt_np = target.squeeze().numpy()
+
+    pred_t = torch.from_numpy(pred_np).unsqueeze(-1)
+    tgt_t = torch.from_numpy(tgt_np).unsqueeze(-1)
+    rel_l2 = torch.mean(
+        torch.norm(pred_t.squeeze(-1) - tgt_t.squeeze(-1), p=2, dim=-1)
+        / torch.norm(tgt_t.squeeze(-1), p=2, dim=-1)
+    )
+    tgt_mean = torch.mean(tgt_t)
+    ss_tot = torch.sum((tgt_t - tgt_mean) ** 2)
+    ss_res = torch.sum((tgt_t - pred_t) ** 2)
+    r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else torch.tensor(0.0)
+
+    p(100)
+    return {
+        "points": np.asarray(points),
+        "pred": np.asarray(pred_np),
+        "tgt": np.asarray(tgt_np),
+        "cosine_score": float(cosine_score),
+        "confidence_score": float(confidence_score),
+        "abs_err": float(np.mean(np.abs(pred_np - tgt_np))),
+        "mse_err": float(np.mean((pred_np - tgt_np) ** 2)),
+        "rel_l2": float(rel_l2.item()),
+        "r_squared": float(r2.item()),
+    }
+
+# ========= VTK helpers =========
+def make_actor_from_stl(stl_path: str, color=(0.85, 0.85, 0.85)):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    tri = vtkTriangleFilter()
+    tri.SetInputConnection(r.GetOutputPort())
+    tri.Update()
+    m = vtkPolyDataMapper()
+    m.SetInputConnection(tri.GetOutputPort())
+    a = vtkActor()
+    a.SetMapper(m)
+    a.GetProperty().SetColor(*color)
+    return a
+
+def build_jet_lut(vmin, vmax):
+    lut = vtkLookupTable()
+    lut.SetRange(float(vmin), float(vmax))
+    lut.SetNumberOfTableValues(256)
+    lut.Build()
+    cmap = cm.get_cmap("jet", 256)
+    for i in range(256):
+        r_, g_, b_, _ = cmap(i)
+        lut.SetTableValue(i, float(r_), float(g_), float(b_), 1.0)
+    return lut
+
+def color_actor_with_scalars_from_prediction(stl_path, points_xyz, pred_vals, array_name, vmin, vmax, lut=None):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    poly = r.GetOutput()
+
+    stl_pts = nps.vtk_to_numpy(poly.GetPoints().GetData())
+    tree = cKDTree(points_xyz)
+    _, nn_idx = tree.query(stl_pts, k=1)
+    scalars = np.asarray(pred_vals, dtype=np.float32)[nn_idx]
+
+    vtk_arr = nps.numpy_to_vtk(scalars, deep=True)
+    vtk_arr.SetName(array_name)
+    poly.GetPointData().AddArray(vtk_arr)
+    poly.GetPointData().SetActiveScalars(array_name)
+
+    mapper = vtkPolyDataMapper()
+    mapper.SetInputData(poly)
+    mapper.SetScalarModeToUsePointData()
+    mapper.ScalarVisibilityOn()
+    mapper.SetScalarRange(float(vmin), float(vmax))
+    if lut is None:
+        lut = build_jet_lut(vmin, vmax)
+    mapper.SetLookupTable(lut)
+    mapper.UseLookupTableScalarRangeOn()
+
+    actor = vtkActor()
+    actor.SetMapper(mapper)
+    return actor
+
+def add_or_update_scalar_bar(renderer, lut, title, label_fmt="%-0.2f", n_labels=8):
+    existing = []
+    ca = renderer.GetActors2D()
+    ca.InitTraversal()
+    for _ in range(ca.GetNumberOfItems()):
+        a = ca.GetNextItem()
+        if isinstance(a, vtkScalarBarActor):
+            existing.append(a)
+    for a in existing:
+        renderer.RemoveActor2D(a)
+
+    sbar = vtkScalarBarActor()
+    sbar.SetLookupTable(lut)
+    sbar.SetOrientationToVertical()
+    sbar.SetLabelFormat(label_fmt)
+    sbar.SetNumberOfLabels(int(n_labels))
+    sbar.SetTitle(title)
+    sbar.SetPosition(0.92, 0.05)
+    sbar.SetPosition2(0.06, 0.90)
+
+    tp = sbar.GetTitleTextProperty()
+    tp.SetColor(1, 1, 1)
+    tp.SetBold(True)
+    tp.SetFontSize(22)
+    lp = sbar.GetLabelTextProperty()
+    lp.SetColor(1, 1, 1)
+    lp.SetFontSize(18)
+
+    renderer.AddActor2D(sbar)
+    return sbar
+
+# ---------- Small helpers ----------
+def poly_count(mesh: pv.PolyData) -> int:
+    if hasattr(mesh, "n_faces_strict"):
+        return mesh.n_faces_strict
+    return mesh.n_cells
+
+def md_to_html(txt: str) -> str:
+    if not txt:
+        return ""
+    safe = _html.escape(txt)
+    safe = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", safe)
+    return "<br/>".join(safe.splitlines())
+
+def bc_text_right(dataset: str) -> str:
+    if dataset == "Incompressible flow over car":
+        return (
+            "<b>Reference Density:</b> 1.225 kg/m³<br><br>"
+            "<b>Reference Viscosity:</b> 1.789e-5 Pa·s<br><br>"
+            "<b>Operating Pressure:</b> 101325 Pa"
+        )
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Ambient Temperature:</b> 218 K<br><br>"
+            "<b>Cruising velocity:</b> 250.0 m/s or 560 mph"
+        )
+    return ""
+
+def bc_text_left(dataset: str) -> str:
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Reference Density:</b> 0.36 kg/m³<br><br>"
+            "<b>Reference viscosity:</b> 1.716e-05 kg/(m·s)<br><br>"
+            "<b>Operating Pressure:</b> 23842 Pa"
+        )
+    return ""
+
+# =====================================================================
+# =======================  APP  =======================================
+# =====================================================================
+class PFMDemo(TrameApp):
+    def __init__(self, server=None):
+        super().__init__(server)
+
+        # ---------------- VTK RENDERERS ----------------
+        self.ren_geom = vtkRenderer()
+        self.ren_geom.SetBackground(0.10, 0.16, 0.22)
+        self.rw_geom = vtkRenderWindow()
+        self.rw_geom.SetOffScreenRendering(1)
+        self.rw_geom.AddRenderer(self.ren_geom)
+        self.rwi_geom = vtkRenderWindowInteractor()
+        self.rwi_geom.SetRenderWindow(self.rw_geom)
+        self.rwi_geom.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_geom.Initialize()
+            self.rwi_geom.Enable()
+        except Exception:
+            pass
+
+        self.ren_pred = vtkRenderer()
+        self.ren_pred.SetBackground(0.10, 0.16, 0.22)
+        self.rw_pred = vtkRenderWindow()
+        self.rw_pred.SetOffScreenRendering(1)
+        self.rw_pred.AddRenderer(self.ren_pred)
+        self.rwi_pred = vtkRenderWindowInteractor()
+        self.rwi_pred.SetRenderWindow(self.rw_pred)
+        self.rwi_pred.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_pred.Initialize()
+            self.rwi_pred.Enable()
+        except Exception:
+            pass
+
+        self.scalar_bar = None
+
+        # timers / flags
+        self._predict_t0 = None
+        self._infer_thread = None
+        self._pre_upload_thread = None
+        self._infer_heartbeat_on = False
+        self._loop = None
+
+        # ---------------- TRAME STATE ----------------
+        s = self.state
+        s.theme_dark = True
+
+        s.analysis_types = ANALYSIS_TYPE
+        s.analysis_type = DEFAULT_ANALYSIS_TYPE
+        s.dataset_choices = ANALYSIS_TYPE_MAPPING[DEFAULT_ANALYSIS_TYPE]
+        s.dataset = DEFAULT_DATASET
+        s.variable_choices = variables_for(DEFAULT_DATASET)
+        s.variable = s.variable_choices[0] if s.variable_choices else None
+
+        # dialog (still kept)
+        s.show_decimation_dialog = False
+        s.decim_override_enabled = False
+        s.decim_override_mode = "medium"
+        s.decim_override_custom = 0.5
+
+        # menu decimation defaults
+        s.decim_enable = False        # user MUST toggle to override auto
+        s.decim_target = 0.5
+        s.decim_min_faces = 5000         # <= important: 0 so small meshes can be reduced
+        s.decim_max_faces = int(1e7)
+
+        # register controller properly
+        # self.server.controller.decimate_again = self.decimate_again
+        # self.server.controller.add("decimate_again", self.decimate_again)
+        ctrl = self.server.controller
+
+        # ✅ this actually registers the trigger
+        ctrl.add("decimate_again", self.decimate_again)
+        ctrl.add("reset_mesh", self.reset_mesh)
+
+
+
+        s.show_velocity = (DEFAULT_DATASET == "Incompressible flow over car")
+        s.is_plane = (DEFAULT_DATASET == "Compressible flow over plane")
+        s.velocity_mph = 45.0
+
+        s.bc_text = get_boundary_conditions_text(DEFAULT_DATASET)
+        s.bc_left = bc_text_left(DEFAULT_DATASET)
+        s.bc_right = bc_text_right(DEFAULT_DATASET)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+        s.stats_html = "👋 Upload a geometry, then click Predict."
+        s.upload = None
+
+        # upload
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.pm_elapsed_upload = 0.0
+        s.upload_msg = ""
+
+        # predict
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.predict_elapsed = 0.0
+        s.predict_est_total = 0.0
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+
+        self._build_ui()
+
+    def _ensure_loop(self):
+        if self._loop is not None:
+            return self._loop
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        self._loop = loop
+        return loop
+
+    def _run_coro(self, coro):
+        loop = self._ensure_loop()
+        if loop.is_running():
+            return asyncio.ensure_future(coro, loop=loop)
+        return loop.run_until_complete(coro)
+
+    async def _flush_async(self):
+        try:
+            self.server.state.flush()
+        except Exception:
+            pass
+        await asyncio.sleep(0)
+
+    def _build_ui(self):
+        ctrl = self.server.controller
+        with SinglePageLayout(self.server, full_height=True) as layout:
+            layout.title.set_text("")    # clear
+            layout.title.hide = True     # hide default
+            with layout.toolbar:
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"      # overall width
+                        "margin: 0 auto;"         # center it
+                        "padding: 0 8px;"        # ← left/right margin
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSpacer()
+                    html.Div(
+                        "Ansys: Physics Foundation Model (Powered by Trame)",
+                        style=(
+                            "width:100%;"
+                            "text-align:center;"
+                            "font-size:34px;"
+                            "font-weight:900;"
+                            "letter-spacing:0.4px;"
+                            "line-height:1.2;"
+                        ),
+                    )
+                    v3.VSpacer()
+
+            # toolbar
+            with layout.toolbar:
+                # ← same margin container for the second toolbar row
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"
+                        "margin: 0 auto;"
+                        "padding: 0 8px;"
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSwitch(
+                        v_model=("theme_dark",),
+                        label="Dark Theme",
+                        inset=True,
+                        density="compact",
+                        hide_details=True,
+                    )
+                    v3.VSpacer()
+
+            with layout.content:
+                html.Style("""
+                /* Small side padding for the whole app */
+                .v-application__wrap {
+                    padding-left: 8px;
+                    padding-right: 8px;
+                    padding-bottom: 8px;
+                }
+
+                :root {
+                    --pfm-font-ui: 'Inter', 'IBM Plex Sans', 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+                    --pfm-font-mono: 'JetBrains Mono', 'IBM Plex Mono', monospace;
+                }
+
+                html, body, .v-application {
+                    margin: 0;
+                    padding: 0;
+                    font-family: var(--pfm-font-ui) !important;
+                    font-weight: 500;
+                    letter-spacing: .25px;
+                    -webkit-font-smoothing: antialiased;
+                    -moz-osx-font-smoothing: grayscale;
+                    text-rendering: optimizeLegibility;
+                    line-height: 1.5;
+                    font-size: 15.5px;
+                    color: #ECEFF4;
+                }
+
+                /* ... keep all your other typography / button / slider styles here ... */
+
+                .v-theme--dark { background-color: #14171C !important; color: #ECEFF4 !important; }
+                .v-theme--light { background-color: #F6F7FA !important; color: #1F1F1F !important; }
+
+                /* (rest of your .pfm-* classes unchanged) */
+                """)
+
+                # html.Style("""
+                # .v-theme--dark { background: #1F232B !important; }
+                # .v-theme--light { background: #f5f6f8 !important; }
+                # .v-theme--dark .pfm-card { background: #23272F !important; color: #fff !important; }
+                # .v-theme--light .pfm-card { background: #ffffff !important; color: #1f232b !important; }
+                # .v-theme--dark .pfm-viewer { background: #15171d !important; }
+                # .v-theme--light .pfm-viewer { background: #e9edf3 !important; }
+                # .pfm-card { border-radius: 16px !important; box-shadow: 0 6px 24px rgba(0,0,0,0.12); }
+                # .pfm-progress .v-progress-linear { height: 22px !important; border-radius: 999px !important; }
+                # .pfm-btn-big.v-btn {
+                #     height: 48px !important;
+                #     font-size: 18px !important;
+                #     font-weight: 600 !important;
+                #     letter-spacing: 1.2px;
+                #     text-transform: none !important;
+                #     border-radius: 999px !important;
+                # }
+                # .pfm-viewer { min-height: 420px; height: 650px !important; border-radius: 16px; }
+                # """)
+                html.Link(
+                    rel="stylesheet",
+                    href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;600&display=swap",
+                )
+
+                with v3.VThemeProvider(theme=("theme_dark ? 'dark' : 'light'",)):
+                    with v3.VContainer(
+                        fluid=True,
+                        class_="pa-6",
+                        style=(
+                            "max-width: 2200px;"                     # max width of content
+                            "margin: 8px auto 16px auto;"          # top / left-right / bottom
+                            "padding: 0 8px;"                      # inner left/right padding
+                            "box-sizing: border-box;"
+                            "background: rgba(255,255,255,0.02);"
+                            "border-radius: 16px;"
+                        ),
+                    ):
+
+
+                        # 1) Physics Application
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧪 <b>Physics Application</b>",
+                                style="font-size:28px;font-weight:700;letter-spacing:1.1px;margin-bottom:10px;",
+                            )
+                            html.Div(
+                                "Select the type of analysis",
+                                style="font-size:24px;opacity:.82;margin-bottom:18px;",
+                            )
+                            toggle = v3.VBtnToggle(
+                                v_model=("analysis_type", self.state.analysis_type),
+                                class_="mt-1",
+                                mandatory=True,
+                                rounded=True,
+                            )
+                            # with toggle:
+                            #     for at in ANALYSIS_TYPE:
+                            #         v3.VBtn(
+                            #             at,
+                            #             value=at,
+                            #             variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                            #             class_="mr-2 pfm-toggle-xxl",
+                            #         )
+
+                            with toggle:
+                                for at in ANALYSIS_TYPE:
+                                    v3.VBtn(
+                                        at,
+                                        value=at,
+                                        variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                                        class_="mr-2 pfm-toggle-xxl",
+                                        style=(
+                                            "font-size:18px;"
+                                            "font-weight:800;"
+                                            "letter-spacing:0.4px;"
+                                            "text-transform:none;"
+                                        ),
+                                    )
+
+                        # 2) Dataset + Variable
+                        with v3.VRow(dense=True, class_="mb-3"):
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "🧩 Sub Application",
+                                        style="font-weight:700;font-size:24px;margin-bottom:14px;",
+                                    )
+                                    v3.VSelect(
+                                        v_model=("dataset", self.state.dataset),
+                                        items=("dataset_choices", self.state.dataset_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        style=(
+                                            "font-size:24px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        class_="pfm-big-select-subapp",
+                                        menu_props={"content_class": "pfm-subapp-list"},  # <— key for dropdown items
+                                    )
+                                    # v3.VSelect(
+                                    #     v_model=("dataset", self.state.dataset),
+                                    #     items=("dataset_choices", self.state.dataset_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     class_="pfm-big-select-subapp pfm-subapp-list",
+                                    #     style="font-size:21px;",
+                                    # )
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "📊 Variable to Predict",
+                                        style="font-weight:700;font-size:20px;margin-bottom:14px;",
+                                    )
+
+                                    v3.VSelect(
+                                        v_model=("variable", self.state.variable),
+                                        items=("variable_choices", self.state.variable_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        class_="pfm-var-select",
+                                        style=(
+                                            "font-size:20px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        menu_props={"content_class": "pfm-var-list"},
+                                    )
+                                                                        # v3.VSelect(
+                                    #     v_model=("variable", self.state.variable),
+                                    #     items=("variable_choices", self.state.variable_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     style="font-size:16px;",
+                                    # )
+
+                        # 3) Boundary Conditions
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧱 Boundary Conditions",
+                                style="font-weight:700;font-size:22px;margin-bottom:16px;",
+                            )
+
+                            # two columns: Left = velocity controls, Right = reference text
+                            with v3.VRow(class_="align-start", dense=True):
+                                # ---- LEFT: velocity slider / readout ----
+                                with v3.VCol(cols=7, class_="pfm-vel"):
+                                    html.Div(
+                                        "🚗 Velocity (mph)",
+                                        class_="pfm-vel-title",
+                                        style="margin-bottom:8px;font-weight:800;font-size:21px;letter-spacing:.3px;",
+                                    )
+                                    html.Div(
+                                        "Set the inlet velocity in miles per hour",
+                                        class_="pfm-vel-sub",
+                                        style="margin-bottom:10px;font-size:20px;opacity:.95;",
+                                    )
+                                    v3.VSlider(
+                                        v_model=("velocity_mph", self.state.velocity_mph),
+                                        min=30.0, max=80.0, step=0.1,
+                                        thumb_label=True,
+                                        v_if=("show_velocity",),
+                                        style="height:54px;margin-top:12px;max-width:540px;",
+                                        class_="mt-3 mb-3 pfm-vel-slider",
+                                    )
+                                    html.Div(
+                                        "{{ velocity_mph.toFixed(0) }} / 80 "
+                                        "<span style='opacity:.95'>"
+                                        "({{ (velocity_mph * 0.44704).toFixed(2) }} m/s)</span>",
+                                        v_if=("show_velocity",),
+                                        class_="pfm-vel-readout",
+                                        style="font-size:18px;font-weight:900;letter-spacing:.3px;margin-top:6px;",
+                                    )
+
+                                # ---- RIGHT: fixed reference values (HTML from bc_text_right / bc_text_left) ----
+                                with v3.VCol(cols=5, class_="pfm-bc-right"):
+                                    html.Div(
+                                        v_html=("bc_text_html", ""),
+                                        style=(
+                                            "margin-top:6px;"
+                                            "font-size:18px;"
+                                            "line-height:1.7;"
+                                            "min-width:260px;"
+                                            "max-width:360px;"
+                                            "text-align:left;"
+                                        ),
+                                    )
+
+                        
+
+                        # 4) Two viewers
+                        with v3.VRow(style="margin-top: 24px;"):
+                            # LEFT = upload
+                            with v3.VCol(cols=6):
+                                with v3.VRow(class_="align-center justify-space-between mb-2"):
+                                    html.Div(
+                                        "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📤 Input Geometry</span>",
+                                    )
+
+                                    # ✅ working gear menu
+                                    with v3.VMenu(
+                                        location="bottom end",
+                                        close_on_content_click=False,
+                                        offset="4 8",
+                                    ):
+                                        # activator slot MUST expose { props } and we MUST bind them to the button
+                                        with v3.Template(v_slot_activator="{ props }"):
+                                            with v3.VBtn(
+                                                icon=True,
+                                                variant="text",
+                                                density="comfortable",
+                                                style="min-width:32px;",
+                                                v_bind="props",               # 👈 this is the key
+                                            ):
+                                                v3.VIcon("mdi-cog", size="22")
+
+                                        # menu content
+                                        with v3.VCard(class_="pa-4", style="min-width: 280px;"):
+                                            html.Div("<b>Mesh decimation</b>", class_="mb-3", style="font-size:14px;")
+
+                                            v3.VSwitch(
+                                                v_model=("decim_enable",),
+                                                label="Enable decimation",
+                                                inset=True,
+                                                hide_details=True,
+                                                class_="mb-4",
+                                            )
+
+                                            html.Div(
+                                                "Target reduction (fraction of faces to remove)",
+                                                class_="mb-1",
+                                                style="font-size:12px;color:#9ca3af;",
+                                            )
+                                            v3.VSlider(
+                                                v_model=("decim_target",),
+                                                min=0.0,
+                                                max=0.999,
+                                                step=0.001,
+                                                hide_details=True,
+                                                class_="mb-2",
+                                            )
+                                            html.Div("{{ decim_target.toFixed(3) }}", style="font-size:11px;", class_="mb-3")
+
+                                            with v3.VRow(dense=True, class_="mb-3"):
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Min faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_min_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Max faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_max_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+
+                                            v3.VBtn(
+                                                "Apply to current mesh",
+                                                block=True,
+                                                color="primary",
+                                                class_="mt-2",
+                                                click=self.decimate_again,
+                                            )
+
+                                            v3.VBtn(
+                                                "Reset to original mesh",
+                                                block=True,
+                                                variant="tonal",
+                                                class_="mt-2",
+                                                click=self.reset_mesh,       # 👈 will call the controller you added
+                                            )
+
+
+                                v3.VFileInput(
+                                    label="Select 3D File",
+                                    style="font-size:17px;padding:12px;height:50px;margin-bottom:20px;",
+                                    multiple=False,
+                                    show_size=True,
+                                    accept=".stl,.vtk,.vtp,.ply,.obj,.vtu,.glb",
+                                    v_model=("upload", None),
+                                    clearable=True,
+                                )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_geom = VtkRemoteView(
+                                        self.rw_geom,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                               rounded=True, elevation=3):
+                                    html.Div("<b>Upload</b>", style="font-size:18px;")
+                                    v3.VProgressLinear(
+                                        v_model=("pm_upload", 0),
+                                        height=22,
+                                        style="margin-top:10px;margin-bottom:10px;",
+                                        color="primary",
+                                        rounded=True,
+                                    )
+                                    html.Div(
+                                        "{{ upload_msg }} — {{ pm_elapsed_upload.toFixed(2) }}s",
+                                        style="font-size:14px;",
+                                    )
+                                v3.VBtn(
+                                    "🗑️ CLEAR",
+                                    block=True,
+                                    variant="tonal",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.clear,
+                                )
+                            # RIGHT = prediction
+                            with v3.VCol(cols=6):
+                                html.Div(
+                                    "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📈 Prediction Results</span>",
+                                    style="margin-bottom:10px;",
+                                )
+                                html.Div(
+                                    v_html=("stats_html",),
+                                    class_="mb-3",
+                                    style="font-size:20px;line-height:1.4;",
+                                )
+                                v3.VProgressLinear(
+                                    v_model=("predict_progress", 0),
+                                    height=22,
+                                    style="margin-top:6px;margin-bottom:12px;",
+                                    color="primary",
+                                    rounded=True,
+                                    indeterminate=("predict_progress < 10",),
+                                    v_show=("is_predicting",),
+                                )
+                                html.Div(
+                                    "Predicting: {{ predict_progress }}%",
+                                    style="font-size:14px;margin-bottom:10px;",
+                                    v_show=("is_predicting",),
+                                )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_pred = VtkRemoteView(
+                                        self.rw_pred,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                               rounded=True, elevation=3):
+                                    html.Div("<b>Inference</b>", style="font-size:18px;")
+                                    v3.VProgressLinear(
+                                        v_model=("pm_infer", 0),
+                                        height=22,
+                                        style="margin-top:10px;margin-bottom:10px;",
+                                        color="success",
+                                        rounded=True,
+                                    )
+                                    html.Div(
+                                        "{{ pm_infer }}% — {{ pm_elapsed_infer.toFixed(2) }}s",
+                                        style="font-size:14px;",
+                                    )
+                                v3.VBtn(
+                                    "🚀 PREDICT",
+                                    block=True,
+                                    color="primary",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.predict,
+                                )
+
+            layout.on_ready = self._first_paint
+
+    def _first_paint(self, **_):
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+    # ---------------------------------------------------------
+    # UPLOAD (async)
+    # ---------------------------------------------------------
+    def _write_upload_to_disk(self, payload) -> str:
+        if payload is None:
+            raise ValueError("No file payload")
+        if isinstance(payload, (list, tuple)):
+            payload = payload[0]
+        if isinstance(payload, str):
+            return payload
+        if not isinstance(payload, dict):
+            raise ValueError(f"Unsupported payload: {type(payload)}")
+        if payload.get("path"):
+            return payload["path"]
+        name = payload.get("name") or "upload"
+        content = payload.get("content")
+        if isinstance(content, str) and content.startswith("data:"):
+            content = content.split(",", 1)[1]
+        raw = base64.b64decode(content) if isinstance(content, str) else bytes(content)
+        os.makedirs(GEOM_DIR, exist_ok=True)
+        file_path = os.path.join(GEOM_DIR, name)
+        with open(file_path, "wb") as f:
+            f.write(raw)
+        return file_path
+
+    def _pre_upload_spinner_loop(self):
+        s = self.state
+        phase = 1
+        while self._pre_upload_on and not self._upload_actual_started and s.is_uploading:
+            s.pm_upload = max(1, min(9, phase))
+            s.upload_msg = "Initializing upload..."
+            try:
+                self.server.state.flush()
+            except Exception:
+                pass
+            phase = 1 if phase >= 9 else phase + 1
+            time.sleep(0.15)
+
+    def _start_pre_upload_spinner(self):
+        if self._pre_upload_thread and self._pre_upload_thread.is_alive():
+            return
+        self._upload_actual_started = False
+        self._pre_upload_on = True
+        self._pre_upload_thread = threading.Thread(
+            target=self._pre_upload_spinner_loop, daemon=True
+        )
+        self._pre_upload_thread.start()
+
+    def _stop_pre_upload_spinner(self):
+        self._pre_upload_on = False
+        self._pre_upload_thread = None
+
+    async def _fake_upload_bump(self, stop_event: asyncio.Event):
+        s = self.state
+        while not stop_event.is_set() and s.pm_upload < 9:
+            s.pm_upload += 1
+            await self._flush_async()
+            await asyncio.sleep(0.05)
+
+    async def _upload_worker_async(self, upload):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        s.is_uploading = True
+        s.upload_msg = "Starting upload..."
+        s.pm_elapsed_upload = 0.0
+
+        s.pm_upload = 5
+        self.server.state.flush()
+        await asyncio.sleep(0)
+
+        fake_stop = asyncio.Event()
+        fake_task = asyncio.create_task(self._fake_upload_bump(fake_stop))
+
+        try:
+            self._upload_actual_started = True
+            self._stop_pre_upload_spinner()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+                try:
+                    await fake_task
+                except asyncio.CancelledError:
+                    pass
+
+            s.upload_msg = "Writing file to disk..."
+            s.pm_upload = 10
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            file_path = await loop.run_in_executor(None, self._write_upload_to_disk, upload)
+
+            s.upload_msg = "Reading mesh..."
+            s.pm_upload = 20
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            mesh = await loop.run_in_executor(None, pv.read, file_path)
+
+            # 3) decimation (auto first)
+            try:
+                nf = poly_count(mesh)
+            except Exception:
+                nf = mesh.n_cells
+
+            auto_tr = float(auto_target_reduction(nf))
+
+            # reflect auto in UI
+            s.decim_target = auto_tr
+            s.decim_min_faces = 5000            # <= allow decimation even for 27k faces
+            s.decim_max_faces = int(1e7)
+
+            target = auto_tr
+            min_faces = 5000
+            max_faces = int(1e7)
+
+            # user override
+            if self.state.decim_enable:
+                target = float(self.state.decim_target or 0.0)
+                min_faces = int(self.state.decim_min_faces or 5000)
+                max_faces = int(self.state.decim_max_faces or 1e7)
+
+            if target > 0.0:
+                s.upload_msg = f"Decimating mesh ({target:.3f})..."
+                s.pm_upload = max(s.pm_upload, 45)
+                s.pm_elapsed_upload = time.time() - t0
+                await self._flush_async()
+
+                dec_cfg = {
+                    "enabled": True,
+                    "method": "pro",
+                    "target_reduction": target,
+                    "min_faces": min_faces,
+                    "max_faces": max_faces,
+                }
+                mesh = await loop.run_in_executor(None, decimate_mesh, mesh, dec_cfg)
+
+            # 4) normals + save
+            s.upload_msg = "Preparing geometry..."
+            s.pm_upload = 75
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            def _normals_and_save(m):
+                m_fixed = m.compute_normals(
+                    consistent_normals=True,
+                    auto_orient_normals=True,
+                    point_normals=True,
+                    cell_normals=False,
+                    inplace=False,
+                )
+                geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+                m_fixed.save(geom_path_)
+                return geom_path_, m_fixed
+
+            geom_path, mesh_fixed = await loop.run_in_executor(None, _normals_and_save, mesh)
+
+            # 5) update viewer
+            self.ren_geom.RemoveAllViewProps()
+            self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+            self.ren_geom.ResetCamera()
+            try:
+                self.rw_geom.Render()
+            except Exception:
+                pass
+            self.view_geom.update()
+            # GEOMETRY_CACHE.current_mesh = mesh_fixed
+            GEOMETRY_CACHE.original_mesh = mesh_fixed.copy(deep=True)
+            GEOMETRY_CACHE.current_mesh = mesh_fixed
+
+            s.upload_msg = "✅ Geometry ready."
+            s.pm_upload = 100
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+        except Exception as e:
+            s.upload_msg = f"❌ Upload failed: {e}"
+            s.pm_upload = 0
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+        finally:
+            s.is_uploading = False
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+            if not fake_task.done():
+                fake_task.cancel()
+                try:
+                    await fake_task
+                except Exception:
+                    pass
+
+    @change("upload")
+    def _on_upload_change(self, upload, **_):
+        if not upload:
+            return
+        self._run_coro(self._upload_worker_async(upload))
+
+    def decimate_again(self):
+        self._run_coro(self._decimate_again_async())
+
+    async def _decimate_again_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            s.upload_msg = "No mesh to re-decimate"
+            await self._flush_async()
+            return
+
+        try:
+            target = float(s.decim_target)
+        except Exception:
+            target = 0.0
+
+        try:
+            min_faces = int(s.decim_min_faces)
+        except Exception:
+            min_faces = 5000
+
+        try:
+            max_faces = int(s.decim_max_faces)
+        except Exception:
+            max_faces = int(1e7)
+
+        if (not s.decim_enable) or target <= 0.0:
+            s.upload_msg = "Decimation disabled"
+            await self._flush_async()
+            return
+
+        s.upload_msg = f"Re-decimating ({target:.3f})..."
+        await self._flush_async()
+
+        dec_cfg = {
+            "enabled": True,
+            "method": "pro",
+            "target_reduction": target,
+            "min_faces": min_faces,
+            "max_faces": max_faces,
+        }
+
+        mesh = await loop.run_in_executor(None, decimate_mesh, GEOMETRY_CACHE.current_mesh, dec_cfg)
+
+        def _normals_and_save(m):
+            m_fixed = m.compute_normals(
+                consistent_normals=True,
+                auto_orient_normals=True,
+                point_normals=True,
+                cell_normals=False,
+                inplace=False,
+            )
+            geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+            m_fixed.save(geom_path_)
+            return geom_path_, m_fixed
+
+        geom_path, mesh_fixed = await loop.run_in_executor(None, _normals_and_save, mesh)
+
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+        self.ren_geom.ResetCamera()
+        try:
+            self.rw_geom.Render()
+        except Exception:
+            pass
+        self.view_geom.update()
+
+        GEOMETRY_CACHE.current_mesh = mesh_fixed
+        s.upload_msg = "✅ Re-decimated"
+        await self._flush_async()
+
+    def reset_mesh(self):
+        self._run_coro(self._reset_mesh_async())
+
+    async def _reset_mesh_async(self):
+        s = self.state
+
+        if GEOMETRY_CACHE.original_mesh is None:
+            s.upload_msg = "No original mesh to reset to"
+            await self._flush_async()
+            return
+
+        # use the saved original
+        orig = GEOMETRY_CACHE.original_mesh
+
+        # save it again as current
+        GEOMETRY_CACHE.current_mesh = orig
+
+        # write to disk (so the STL on disk matches the viewer)
+        geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+        orig.save(geom_path)
+
+        # update viewer
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+        self.ren_geom.ResetCamera()
+        try:
+            self.rw_geom.Render()
+        except Exception:
+            pass
+        self.view_geom.update()
+
+        s.upload_msg = "↩️ Reset to original mesh"
+        await self._flush_async()
+
+    # ---------------------------------------------------------
+    # prediction
+    # ---------------------------------------------------------
+    def _start_infer_heartbeat(self):
+        if self._infer_thread and self._infer_thread.is_alive():
+            return
+
+        def loop_fn():
+            while self._infer_heartbeat_on:
+                if self.state.is_predicting and self._predict_t0 is not None:
+                    self.state.pm_elapsed_infer = max(0.0, time.time() - self._predict_t0)
+                    try:
+                        self.server.state.flush()
+                    except Exception:
+                        pass
+                time.sleep(0.12)
+
+        self._infer_heartbeat_on = True
+        self._infer_thread = threading.Thread(target=loop_fn, daemon=True)
+        self._infer_thread.start()
+
+    def _stop_infer_heartbeat(self):
+        self._infer_heartbeat_on = False
+        self._infer_thread = None
+
+    async def _predict_worker_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            s.predict_msg = "❌ Please upload geometry first"
+            s.is_predicting = False
+            await self._flush_async()
+            return
+
+        s.is_predicting = True
+        s.predict_progress = 1
+        s.pm_infer = 1
+        s.predict_msg = "Preparing inference..."
+        self._predict_t0 = time.time()
+        self._start_infer_heartbeat()
+        await self._flush_async()
+
+        try:
+            dataset = s.dataset
+            variable = s.variable
+            boundary = (
+                {"freestream_velocity": mph_to_ms(s.velocity_mph)}
+                if dataset == "Incompressible flow over car"
+                else None
+            )
+
+            s.predict_msg = "Loading model/checkpoint..."
+            s.predict_progress = 5
+            s.pm_infer = 5
+            await self._flush_async()
+
+            cfg, model, device, _ = await loop.run_in_executor(
+                None, MODEL_STORE.get, dataset, variable, None
+            )
+
+            s.predict_msg = "Processing mesh for inference..."
+            s.predict_progress = 35
+            s.pm_infer = 35
+            await self._flush_async()
+
+            def _run_full():
+                return run_inference_fast(
+                    dataset,
+                    variable,
+                    boundary_conditions=boundary,
+                    progress_cb=None,
+                )
+            viz = await loop.run_in_executor(None, _run_full)
+
+            s.predict_msg = "Preparing visualization..."
+            s.predict_progress = 85
+            s.pm_infer = 85
+            await self._flush_async()
+
+            stl_path = os.path.join(GEOM_DIR, "geometry.stl")
+            vmin = float(np.min(viz["pred"]))
+            vmax = float(np.max(viz["pred"]))
+
+            if os.path.exists(stl_path):
+                _tmp_trimesh, vmin, vmax = create_visualization_stl(viz, stl_path)
+                lut = build_jet_lut(vmin, vmax)
+                colored_actor = color_actor_with_scalars_from_prediction(
+                    stl_path,
+                    viz["points"],
+                    viz["pred"],
+                    variable,
+                    vmin,
+                    vmax,
+                    lut=lut,
+                )
+                self.ren_pred.AddActor(colored_actor)
+
+                units = {
+                    "pressure": "Pa",
+                    "x_velocity": "m/s",
+                    "y_velocity": "m/s",
+                    "z_velocity": "m/s",
+                }.get(variable, "")
+                title = f"{variable} ({units})" if units else variable
+                self.scalar_bar = add_or_update_scalar_bar(
+                    self.ren_pred, lut, title, label_fmt="%-0.2f", n_labels=8
+                )
+
+                src_cam = self.ren_geom.GetActiveCamera()
+                dst_cam = self.ren_pred.GetActiveCamera()
+                if src_cam is not None and dst_cam is not None:
+                    dst_cam.SetPosition(src_cam.GetPosition())
+                    dst_cam.SetFocalPoint(src_cam.GetFocalPoint())
+                    dst_cam.SetViewUp(src_cam.GetViewUp())
+                    dst_cam.SetParallelScale(src_cam.GetParallelScale())
+                    cr = src_cam.GetClippingRange()
+                    dst_cam.SetClippingRange(cr)
+
+                try:
+                    self.rw_pred.Render()
+                except Exception:
+                    pass
+                self.view_pred.update()
+
+            raw_vmin = float(np.min(viz["pred"]))
+            raw_vmax = float(np.max(viz["pred"]))
+
+            s.stats_html = (
+                f"<b>{variable} min:</b>{raw_vmin:.3e} "
+                f"<b>max:</b> {raw_vmax:.3e} "
+                f"<b>Confidence:</b> {viz['confidence_score']:.4f}"
+            )
+
+            s.predict_msg = "✅ Prediction complete."
+            s.predict_progress = 100
+            s.pm_infer = 100
+            s.predict_elapsed = time.time() - t0
+            s.pm_elapsed_infer = s.predict_elapsed
+            await self._flush_async()
+
+        except Exception as e:
+            s.predict_msg = f"❌ Prediction failed: {e}"
+            s.predict_progress = 0
+            s.pm_infer = 0
+            await self._flush_async()
+        finally:
+            s.is_predicting = False
+            self._stop_infer_heartbeat()
+            await self._flush_async()
+
+    @time_function("Inference and Visualization")
+    def predict(self, *_):
+        self._run_coro(self._predict_worker_async())
+
+    # ---------------------------------------------------------
+    # dataset wiring
+    # ---------------------------------------------------------
+    @change("analysis_type")
+    def _on_analysis_type_change(self, analysis_type=None, **_):
+        ds_list = ANALYSIS_TYPE_MAPPING.get(analysis_type or "", [])
+        default_ds = ds_list[0] if ds_list else None
+        self.state.dataset_choices = ds_list
+        if default_ds and self.state.dataset != default_ds:
+            self.state.dataset = default_ds
+        elif self.state.dataset:
+            self._apply_dataset(self.state.dataset)
+
+    @change("dataset")
+    def _on_dataset_change(self, dataset=None, **_):
+        if not dataset:
+            return
+        self._apply_dataset(dataset)
+
+    def _apply_dataset(self, ds: str):
+        s = self.state
+        opts = variables_for(ds) if ds else []
+        s.variable_choices = opts
+        s.variable = opts[0] if opts else None
+
+        s.show_velocity = (ds == "Incompressible flow over car")
+        s.is_plane = (ds == "Compressible flow over plane")
+
+        s.bc_text = get_boundary_conditions_text(ds)
+        s.bc_left = bc_text_left(ds)
+        s.bc_right = bc_text_right(ds)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+    # ---------------------------------------------------------
+    # clear
+    # ---------------------------------------------------------
+    def clear(self, *_):
+        for d in [GEOM_DIR, SOLN_DIR]:
+            if os.path.exists(d):
+                shutil.rmtree(d)
+            os.makedirs(d, exist_ok=True)
+        s = self.state
+        s.stats_html = "🧹 Cleared. Upload again."
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.upload_msg = ""
+        s.pm_elapsed_upload = 0.0
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_pred.RemoveAllViewProps()
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+# ---------- main ----------
+def main():
+    app = PFMDemo()
+    app.server.controller.add("decimate_again", app.decimate_again)
+    app.server.controller.add("reset_mesh", app.reset_mesh)
+    app.server.start(7872)
+
+if __name__ == "__main__":
+    main()

Main_app_trame2.py

@@ -0,0 +1,1766 @@
+# ========= Headless / Offscreen safety (before any VTK import) =========
+import os
+os.environ.setdefault("VTK_DEFAULT_RENDER_WINDOW_OFFSCREEN", "1")
+os.environ.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+os.environ.setdefault("MESA_LOADER_DRIVER_OVERRIDE", "llvmpipe")
+os.environ.setdefault("MESA_GL_VERSION_OVERRIDE", "3.3")
+os.environ.setdefault("DISPLAY", "")
+
+# ========= Core setup =========
+import shutil, time, tempfile, json, base64, threading, re, html as _html, asyncio
+import numpy as np
+import torch
+import pyvista as pv
+from scipy.spatial import cKDTree
+from vtk.util import numpy_support as nps
+import matplotlib.cm as cm
+
+from omegaconf import OmegaConf
+from huggingface_hub import hf_hub_download
+from accelerate import Accelerator
+from accelerate.utils import DistributedDataParallelKwargs
+import pickle
+from sklearn.metrics import pairwise_distances
+from train import get_single_latent
+from sklearn.neighbors import NearestNeighbors
+
+from utils.app_utils2 import (
+    create_visualization_points,
+    create_visualization_stl,
+    camera_from_bounds,
+    bounds_from_points,
+    convert_vtp_to_glb,
+    convert_vtp_to_stl,
+    time_function,
+    print_timing,
+    mesh_get_variable,
+    mph_to_ms,
+    get_boundary_conditions_text,
+    compute_confidence_score,
+    compute_cosine_score,
+    decimate_mesh,
+)
+
+# ========= trame =========
+from trame.app import TrameApp
+from trame.decorators import change
+from trame.ui.vuetify3 import SinglePageLayout
+from trame.widgets import vuetify3 as v3, html
+from trame_vtk.widgets.vtk import VtkRemoteView
+
+# ========= VTK =========
+from vtkmodules.vtkRenderingCore import (
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkPolyDataMapper,
+    vtkActor,
+    vtkRenderWindowInteractor,
+)
+from vtkmodules.vtkRenderingAnnotation import vtkScalarBarActor
+from vtkmodules.vtkIOGeometry import vtkSTLReader
+from vtkmodules.vtkFiltersCore import vtkTriangleFilter
+from vtkmodules.vtkCommonCore import vtkLookupTable
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+
+# ========= Writable paths / caches =========
+DATA_DIR = os.path.join(tempfile.gettempdir(), "appdata")
+os.makedirs(DATA_DIR, exist_ok=True)
+os.environ.setdefault("MPLCONFIGDIR", DATA_DIR)
+
+GEOM_DIR = os.path.join(DATA_DIR, "geometry")
+SOLN_DIR = os.path.join(DATA_DIR, "solution")
+WEIGHTS_DIR = os.path.join(DATA_DIR, "weights")
+for d in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR):
+    os.makedirs(d, exist_ok=True)
+
+HF_DIR = os.path.join(DATA_DIR, "hf_home")
+os.environ.setdefault("HF_HOME", HF_DIR)
+os.environ.setdefault("HUGGINGFACE_HUB_CACHE", HF_DIR)
+os.environ.setdefault("TRANSFORMERS_CACHE", HF_DIR)
+os.makedirs(HF_DIR, exist_ok=True)
+for p in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR, HF_DIR):
+    if not os.access(p, os.W_OK):
+        raise RuntimeError(f"Not writable: {p}")
+
+# ========= Auto-decimation ladder =========
+def auto_target_reduction(num_cells: int) -> float:
+    if num_cells <= 10_000:
+        return 0.0
+    elif num_cells <= 20_000:
+        return 0.2
+    elif num_cells <= 50_000:
+        return 0.4
+    elif num_cells <= 100_000:
+        return 0.5
+    elif num_cells <= 500_000:
+        return 0.6
+    elif num_cells < 1_000_000:
+        return 0.8
+    else:
+        return 0.9
+
+# ========= Registry / choices =========
+REGISTRY = {
+    "Incompressible flow inside artery": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow inside artery/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_artery.pt"},
+        "out_variable": ["pressure", "x_velocity", "y_velocity", "z_velocity"],
+    },
+    "Vehicle crash analysis": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Vehicle crash analysis/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_vehiclecrash.pt"},
+        "out_variable": [
+            "impact_force",
+            "deformation",
+            "energy_absorption",
+            "x_displacement",
+            "y_displacement",
+            "z_displacement",
+        ],
+    },
+    "Compressible flow over plane": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Compressible flow over plane/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_plane_transonic_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+    "Incompressible flow over car": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow over car/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_cadillac_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+}
+
+def variables_for(dataset: str):
+    spec = REGISTRY.get(dataset, {})
+    ov = spec.get("out_variable")
+    if isinstance(ov, str):
+        return [ov]
+    if isinstance(ov, (list, tuple)):
+        return list(ov)
+    return list(spec.get("checkpoints", {}).keys())
+
+ANALYSIS_TYPE_MAPPING = {
+    "External flow": ["Incompressible flow over car", "Compressible flow over plane"],
+    "Internal flow": ["Incompressible flow inside artery"],
+    "Crash analysis": ["Vehicle crash analysis"],
+}
+ANALYSIS_TYPE = list(ANALYSIS_TYPE_MAPPING.keys())
+DEFAULT_ANALYSIS_TYPE = "External flow"
+DEFAULT_DATASET = "Incompressible flow over car"
+VAR_CHOICES0 = variables_for(DEFAULT_DATASET)
+DEFAULT_VARIABLE = VAR_CHOICES0[0] if VAR_CHOICES0 else None
+
+# ========= Simple cache =========
+class GeometryCache:
+    def __init__(self):
+        self.original_mesh = None   # uploaded, cleaned (normals), BEFORE user re-decimation
+        self.current_mesh = None    # what the app is actually using right now
+
+GEOMETRY_CACHE = GeometryCache()
+
+# ========= Model store =========
+class ModelStore:
+    def __init__(self):
+        self._cache = {}
+
+    def _build(self, dataset: str, progress_cb=None):
+        def tick(x):
+            if progress_cb:
+                try:
+                    progress_cb(int(x))
+                except:
+                    pass
+
+        if dataset in self._cache:
+            tick(12)
+            return self._cache[dataset]
+
+        print(f"🔧 Building model for {dataset}")
+        start_time = time.time()
+        try:
+            spec = REGISTRY[dataset]
+            repo_id = spec["repo_id"]
+            ckpt_name = spec["checkpoints"]["best_val"]
+
+            tick(6)
+            t0 = time.time()
+            ckpt_path_hf = hf_hub_download(
+                repo_id=repo_id,
+                filename=ckpt_name,
+                repo_type="model",
+                local_dir=HF_DIR,
+                local_dir_use_symlinks=False,
+            )
+            print_timing("Model checkpoint download", t0)
+            tick(8)
+
+            t0 = time.time()
+            ckpt_local_dir = os.path.join(WEIGHTS_DIR, dataset)
+            os.makedirs(ckpt_local_dir, exist_ok=True)
+            ckpt_path = os.path.join(ckpt_local_dir, ckpt_name)
+            if not os.path.exists(ckpt_path):
+                shutil.copy(ckpt_path_hf, ckpt_path)
+            print_timing("Local model copy setup", t0)
+            tick(9)
+
+            t0 = time.time()
+            cfg_path = spec["config"]
+            if not os.path.exists(cfg_path):
+                raise FileNotFoundError(f"Missing config: {cfg_path}")
+            cfg = OmegaConf.load(cfg_path)
+            cfg.save_latent = True
+            print_timing("Configuration loading", t0)
+            tick(11)
+
+            t0 = time.time()
+            os.environ["CUDA_VISIBLE_DEVICES"] = str(getattr(cfg, "gpu_id", 0))
+            ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+            accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            print_timing("Device init", t0)
+            tick(12)
+
+            t0 = time.time()
+            import models
+            model_cls_name = spec["model_attr"]
+            if not hasattr(models, model_cls_name):
+                raise ValueError(f"Model '{model_cls_name}' not found")
+            model = getattr(models, model_cls_name)(cfg).to(device)
+            print_timing("Model build", t0)
+            tick(14)
+
+            t0 = time.time()
+            state = torch.load(ckpt_path, map_location=device)
+            model.load_state_dict(state)
+            model.eval()
+            print_timing("Weights load", t0)
+            tick(15)
+
+            result = (cfg, model, device, accelerator)
+            self._cache[dataset] = result
+            print_timing(f"Total model build for {dataset}", start_time)
+            return result
+        except Exception as e:
+            print_timing(f"Model build failed for {dataset}", e)
+            raise RuntimeError(f"Failed to load model for dataset '{dataset}': {e}")
+
+    def get(self, dataset: str, variable: str, progress_cb=None):
+        return self._build(dataset, progress_cb=progress_cb)
+
+MODEL_STORE = ModelStore()
+
+# ========= Inference pipeline =========
+def _variable_index(dataset: str, variable: str) -> int:
+    ov = REGISTRY[dataset]["out_variable"]
+    return 0 if isinstance(ov, str) else ov.index(variable)
+
+@time_function("Mesh Processing")
+def process_mesh_fast(mesh: pv.DataSet, cfg, variable, dataset, boundary_conditions=None):
+    jpath = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+    json_data = json.load(open(jpath, "r"))
+
+    pts = np.asarray(mesh.points, dtype=np.float32)
+    N = pts.shape[0]
+    rng = np.random.default_rng(42)
+    idx = rng.permutation(N)
+    points = pts[idx]
+    tgt_np = mesh_get_variable(mesh, variable, N)[idx]
+    pos = torch.from_numpy(points)
+    target = torch.from_numpy(tgt_np).unsqueeze(-1)
+
+    if getattr(cfg, "diff_input_velocity", False) and boundary_conditions is not None:
+        if "freestream_velocity" in boundary_conditions:
+            inlet_x_velocity = torch.tensor(boundary_conditions["freestream_velocity"]).float().reshape(1, 1)
+            inlet_x_velocity = inlet_x_velocity.repeat(N, 1)[idx]
+            pos = torch.cat((pos, inlet_x_velocity), dim=1)
+
+    if getattr(cfg, "input_normalization", None) == "shift_axis":
+        coords = pos[:, :3].clone()
+        coords[:, 0] = coords[:, 0] - coords[:, 0].min()
+        coords[:, 2] = coords[:, 2] - coords[:, 2].min()
+        y_center = (coords[:, 1].max() + coords[:, 1].min()) / 2.0
+        coords[:, 1] = coords[:, 1] - y_center
+        pos[:, :3] = coords
+
+    if getattr(cfg, "pos_embed_sincos", False):
+        mins = torch.tensor(json_data["mesh_stats"]["min"], dtype=torch.float32)
+        maxs = torch.tensor(json_data["mesh_stats"]["max"], dtype=torch.float32)
+        pos = 1000.0 * (pos - mins) / (maxs - mins)
+        pos = torch.clamp(pos, 0, 1000)
+
+    cosine_score = compute_cosine_score(mesh, dataset)
+    return pos, target, points, cosine_score
+
+@time_function("Inference")
+def run_inference_fast(dataset: str, variable: str, boundary_conditions=None, progress_cb=None):
+    def p(v):
+        if progress_cb:
+            try:
+                progress_cb(int(v))
+            except Exception:
+                pass
+
+    if GEOMETRY_CACHE.current_mesh is None:
+        raise ValueError("No geometry loaded")
+
+    p(5)
+    cfg, model, device, _ = MODEL_STORE.get(dataset, variable, progress_cb=p)
+    p(15)
+
+    pos, target, points, cosine_score = process_mesh_fast(
+        GEOMETRY_CACHE.current_mesh, cfg, variable, dataset, boundary_conditions
+    )
+    p(25)
+
+    confidence_score = 0.0
+    try:
+        if dataset not in ["Incompressible flow inside artery"]:
+            geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+            latent_features = get_single_latent(
+                mesh_path=geom_path,
+                config_path=os.path.join("configs/app_configs/", dataset, "config.yaml"),
+                device=device,
+                custom_velocity=boundary_conditions["freestream_velocity"] if boundary_conditions else None,
+                use_training_velocity=False,
+                model=model,
+            )
+
+            embedding_path = os.path.join("configs/app_configs/", dataset, "pca_embedding.npy")
+            pca_reducer_path = os.path.join("configs/app_configs/", dataset, "pca_reducer.pkl")
+            scaler_path = os.path.join("configs/app_configs/", dataset, "pca_scaler.pkl")
+
+            embedding = np.load(embedding_path)
+            pca_reducer = pickle.load(open(pca_reducer_path, "rb"))
+            scaler = pickle.load(open(scaler_path, "rb"))
+
+            train_pair_dists = pairwise_distances(embedding)
+            sigma = float(np.median(train_pair_dists)) if train_pair_dists.size > 0 else 1.0
+
+            n_points, n_features = latent_features.shape
+            np.random.seed(42)
+            target_len = int(pca_reducer.n_features_in_ / 256)
+            if n_points > target_len:
+                latent_features = latent_features[np.random.choice(n_points, target_len, replace=False)]
+            elif n_points < target_len:
+                num_extra = target_len - n_points
+                extra_indices = np.random.choice(n_points, num_extra, replace=True)
+                latent_features = np.vstack([latent_features, latent_features[extra_indices]])
+
+            latent_features = latent_features.flatten()
+
+            confidence_score = compute_confidence_score(
+                latent_features, embedding, scaler, pca_reducer, sigma
+            )
+    except Exception:
+        confidence_score = 0.0
+
+    data = {
+        "input_pos": pos.unsqueeze(0).to(device),
+        "output_feat": target.unsqueeze(0).to(device),
+    }
+
+    with torch.no_grad():
+        inp = data["input_pos"]
+        _, N, _ = inp.shape
+        chunk = int(getattr(cfg, "num_points", 10000))
+
+        if getattr(cfg, "chunked_eval", False) and chunk < N:
+            input_pos = data["input_pos"]
+            chunk_size = cfg.num_points
+            out_chunks = []
+            total = (N + chunk_size - 1) // chunk_size
+
+            for k, i in enumerate(range(0, N, chunk_size)):
+                ch = input_pos[:, i : i + chunk_size, :]
+                n_valid = ch.shape[1]
+
+                if n_valid < chunk_size:
+                    pad = input_pos[:, : chunk_size - n_valid, :]
+                    ch = torch.cat([ch, pad], dim=1)
+
+                data["input_pos"] = ch
+                out_chunk = model(data)
+                if isinstance(out_chunk, (tuple, list)):
+                    out_chunk = out_chunk[0]
+                out_chunks.append(out_chunk[:, :n_valid, :])
+
+                p(25 + 60 * (k + 1) / max(1, total))
+
+            outputs = torch.cat(out_chunks, dim=1)
+
+        else:
+            p(40)
+            outputs = model(data)
+            if isinstance(outputs, (tuple, list)):
+                outputs = outputs[0]
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+            p(85)
+
+    vi = _variable_index(dataset, variable)
+    pred = outputs[0, :, vi : vi + 1]
+
+    if getattr(cfg, "normalization", "") == "std_norm":
+        fp = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+        j = json.load(open(fp, "r"))
+        mu = torch.tensor(float(j["scalars"][variable]["mean"]), device=pred.device)
+        sd = torch.tensor(float(j["scalars"][variable]["std"]), device=pred.device)
+        pred = pred * sd + mu
+
+    pred_np = pred.squeeze().detach().cpu().numpy()
+    tgt_np = target.squeeze().numpy()
+
+    pred_t = torch.from_numpy(pred_np).unsqueeze(-1)
+    tgt_t = torch.from_numpy(tgt_np).unsqueeze(-1)
+    rel_l2 = torch.mean(
+        torch.norm(pred_t.squeeze(-1) - tgt_t.squeeze(-1), p=2, dim=-1)
+        / torch.norm(tgt_t.squeeze(-1), p=2, dim=-1)
+    )
+    tgt_mean = torch.mean(tgt_t)
+    ss_tot = torch.sum((tgt_t - tgt_mean) ** 2)
+    ss_res = torch.sum((tgt_t - pred_t) ** 2)
+    r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else torch.tensor(0.0)
+
+    p(100)
+    return {
+        "points": np.asarray(points),
+        "pred": np.asarray(pred_np),
+        "tgt": np.asarray(tgt_np),
+        "cosine_score": float(cosine_score),
+        "confidence_score": float(confidence_score),
+        "abs_err": float(np.mean(np.abs(pred_np - tgt_np))),
+        "mse_err": float(np.mean((pred_np - tgt_np) ** 2)),
+        "rel_l2": float(rel_l2.item()),
+        "r_squared": float(r2.item()),
+    }
+
+# ========= VTK helpers =========
+def make_actor_from_stl(stl_path: str, color=(0.85, 0.85, 0.85)):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    tri = vtkTriangleFilter()
+    tri.SetInputConnection(r.GetOutputPort())
+    tri.Update()
+    m = vtkPolyDataMapper()
+    m.SetInputConnection(tri.GetOutputPort())
+    a = vtkActor()
+    a.SetMapper(m)
+    a.GetProperty().SetColor(*color)
+    return a
+
+def build_jet_lut(vmin, vmax):
+    lut = vtkLookupTable()
+    lut.SetRange(float(vmin), float(vmax))
+    lut.SetNumberOfTableValues(256)
+    lut.Build()
+    cmap = cm.get_cmap("jet", 256)
+    for i in range(256):
+        r_, g_, b_, _ = cmap(i)
+        lut.SetTableValue(i, float(r_), float(g_), float(b_), 1.0)
+    return lut
+
+def color_actor_with_scalars_from_prediction(stl_path, points_xyz, pred_vals, array_name, vmin, vmax, lut=None):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    poly = r.GetOutput()
+
+    stl_pts = nps.vtk_to_numpy(poly.GetPoints().GetData())
+    tree = cKDTree(points_xyz)
+    _, nn_idx = tree.query(stl_pts, k=1)
+    scalars = np.asarray(pred_vals, dtype=np.float32)[nn_idx]
+
+    vtk_arr = nps.numpy_to_vtk(scalars, deep=True)
+    vtk_arr.SetName(array_name)
+    poly.GetPointData().AddArray(vtk_arr)
+    poly.GetPointData().SetActiveScalars(array_name)
+
+    mapper = vtkPolyDataMapper()
+    mapper.SetInputData(poly)
+    mapper.SetScalarModeToUsePointData()
+    mapper.ScalarVisibilityOn()
+    mapper.SetScalarRange(float(vmin), float(vmax))
+    if lut is None:
+        lut = build_jet_lut(vmin, vmax)
+    mapper.SetLookupTable(lut)
+    mapper.UseLookupTableScalarRangeOn()
+
+    actor = vtkActor()
+    actor.SetMapper(mapper)
+    return actor
+
+def add_or_update_scalar_bar(renderer, lut, title, label_fmt="%-0.2f", n_labels=8):
+    existing = []
+    ca = renderer.GetActors2D()
+    ca.InitTraversal()
+    for _ in range(ca.GetNumberOfItems()):
+        a = ca.GetNextItem()
+        if isinstance(a, vtkScalarBarActor):
+            existing.append(a)
+    for a in existing:
+        renderer.RemoveActor2D(a)
+
+    sbar = vtkScalarBarActor()
+    sbar.SetLookupTable(lut)
+    sbar.SetOrientationToVertical()
+    sbar.SetLabelFormat(label_fmt)
+    sbar.SetNumberOfLabels(int(n_labels))
+    sbar.SetTitle(title)
+    sbar.SetPosition(0.92, 0.05)
+    sbar.SetPosition2(0.06, 0.90)
+
+    tp = sbar.GetTitleTextProperty()
+    tp.SetColor(1, 1, 1)
+    tp.SetBold(True)
+    tp.SetFontSize(22)
+    lp = sbar.GetLabelTextProperty()
+    lp.SetColor(1, 1, 1)
+    lp.SetFontSize(18)
+
+    renderer.AddActor2D(sbar)
+    return sbar
+
+# ---------- Small helpers ----------
+def poly_count(mesh: pv.PolyData) -> int:
+    if hasattr(mesh, "n_faces_strict"):
+        return mesh.n_faces_strict
+    return mesh.n_cells
+
+def md_to_html(txt: str) -> str:
+    if not txt:
+        return ""
+    safe = _html.escape(txt)
+    safe = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", safe)
+    return "<br/>".join(safe.splitlines())
+
+def bc_text_right(dataset: str) -> str:
+    if dataset == "Incompressible flow over car":
+        return (
+            "<b>Reference Density:</b> 1.225 kg/m³<br><br>"
+            "<b>Reference Viscosity:</b> 1.789e-5 Pa·s<br><br>"
+            "<b>Operating Pressure:</b> 101325 Pa"
+        )
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Ambient Temperature:</b> 218 K<br><br>"
+            "<b>Cruising velocity:</b> 250.0 m/s or 560 mph"
+        )
+    return ""
+
+def bc_text_left(dataset: str) -> str:
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Reference Density:</b> 0.36 kg/m³<br><br>"
+            "<b>Reference viscosity:</b> 1.716e-05 kg/(m·s)<br><br>"
+            "<b>Operating Pressure:</b> 23842 Pa"
+        )
+    return ""
+
+# =====================================================================
+# =======================  APP  =======================================
+# =====================================================================
+class PFMDemo(TrameApp):
+    def __init__(self, server=None):
+        super().__init__(server)
+
+        # ---------------- VTK RENDERERS ----------------
+        self.ren_geom = vtkRenderer()
+        self.ren_geom.SetBackground(0.10, 0.16, 0.22)
+        self.rw_geom = vtkRenderWindow()
+        self.rw_geom.SetOffScreenRendering(1)
+        self.rw_geom.AddRenderer(self.ren_geom)
+        self.rwi_geom = vtkRenderWindowInteractor()
+        self.rwi_geom.SetRenderWindow(self.rw_geom)
+        self.rwi_geom.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_geom.Initialize()
+            self.rwi_geom.Enable()
+        except Exception:
+            pass
+
+        self.ren_pred = vtkRenderer()
+        self.ren_pred.SetBackground(0.10, 0.16, 0.22)
+        self.rw_pred = vtkRenderWindow()
+        self.rw_pred.SetOffScreenRendering(1)
+        self.rw_pred.AddRenderer(self.ren_pred)
+        self.rwi_pred = vtkRenderWindowInteractor()
+        self.rwi_pred.SetRenderWindow(self.rw_pred)
+        self.rwi_pred.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_pred.Initialize()
+            self.rwi_pred.Enable()
+        except Exception:
+            pass
+
+        self.scalar_bar = None
+
+        # timers / flags
+        self._predict_t0 = None
+        self._infer_thread = None
+        self._pre_upload_thread = None
+        self._infer_heartbeat_on = False
+        self._loop = None
+
+        # ---------------- TRAME STATE ----------------
+        s = self.state
+        s.theme_dark = True
+
+        s.analysis_types = ANALYSIS_TYPE
+        s.analysis_type = DEFAULT_ANALYSIS_TYPE
+        s.dataset_choices = ANALYSIS_TYPE_MAPPING[DEFAULT_ANALYSIS_TYPE]
+        s.dataset = DEFAULT_DATASET
+        s.variable_choices = variables_for(DEFAULT_DATASET)
+        s.variable = s.variable_choices[0] if s.variable_choices else None
+
+        # dialog (still kept)
+        s.show_decimation_dialog = False
+        s.decim_override_enabled = False
+        s.decim_override_mode = "medium"
+        s.decim_override_custom = 0.5
+
+        # menu decimation defaults
+        s.decim_enable = False        # user MUST toggle to override auto
+        s.decim_target = 0.5
+        s.decim_min_faces = 5000         # <= important: 0 so small meshes can be reduced
+        s.decim_max_faces = int(1e7)
+
+        # register controller properly
+        # self.server.controller.decimate_again = self.decimate_again
+        # self.server.controller.add("decimate_again", self.decimate_again)
+        ctrl = self.server.controller
+
+        # ✅ this actually registers the trigger
+        ctrl.add("decimate_again", self.decimate_again)
+        ctrl.add("reset_mesh", self.reset_mesh)
+
+
+
+        s.show_velocity = (DEFAULT_DATASET == "Incompressible flow over car")
+        s.is_plane = (DEFAULT_DATASET == "Compressible flow over plane")
+        s.velocity_mph = 45.0
+
+        s.bc_text = get_boundary_conditions_text(DEFAULT_DATASET)
+        s.bc_left = bc_text_left(DEFAULT_DATASET)
+        s.bc_right = bc_text_right(DEFAULT_DATASET)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+        s.stats_html = "👋 Upload a geometry, then click Predict."
+        s.upload = None
+
+        # upload
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.pm_elapsed_upload = 0.0
+        s.upload_msg = ""
+
+        # predict
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.predict_elapsed = 0.0
+        s.predict_est_total = 0.0
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+
+        self._build_ui()
+
+    def _ensure_loop(self):
+        if self._loop is not None:
+            return self._loop
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        self._loop = loop
+        return loop
+
+    def _run_coro(self, coro):
+        loop = self._ensure_loop()
+        if loop.is_running():
+            return asyncio.ensure_future(coro, loop=loop)
+        return loop.run_until_complete(coro)
+
+    async def _flush_async(self):
+        try:
+            self.server.state.flush()
+        except Exception:
+            pass
+        await asyncio.sleep(0)
+
+    def _build_ui(self):
+        ctrl = self.server.controller
+        with SinglePageLayout(self.server, full_height=True) as layout:
+            layout.title.set_text("")    # clear
+            layout.title.hide = True     # hide default
+            with layout.toolbar:
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"      # overall width
+                        "margin: 0 auto;"         # center it
+                        "padding: 0 8px;"        # ← left/right margin
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSpacer()
+                    html.Div(
+                        "Ansys: Physics Foundation Model",
+                        style=(
+                            "width:100%;"
+                            "text-align:center;"
+                            "font-size:34px;"
+                            "font-weight:900;"
+                            "letter-spacing:0.4px;"
+                            "line-height:1.2;"
+                        ),
+                    )
+                    v3.VSpacer()
+
+            # toolbar
+            with layout.toolbar:
+                # ← same margin container for the second toolbar row
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"
+                        "margin: 0 auto;"
+                        "padding: 0 8px;"
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSwitch(
+                        v_model=("theme_dark",),
+                        label="Dark Theme",
+                        inset=True,
+                        density="compact",
+                        hide_details=True,
+                    )
+                    v3.VSpacer()
+
+            with layout.content:
+                html.Style("""
+                /* Small side padding for the whole app */
+                .v-application__wrap {
+                    padding-left: 8px;
+                    padding-right: 8px;
+                    padding-bottom: 8px;
+                }
+
+                :root {
+                    --pfm-font-ui: 'Inter', 'IBM Plex Sans', 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+                    --pfm-font-mono: 'JetBrains Mono', 'IBM Plex Mono', monospace;
+                }
+
+                html, body, .v-application {
+                    margin: 0;
+                    padding: 0;
+                    font-family: var(--pfm-font-ui) !important;
+                    font-weight: 500;
+                    letter-spacing: .25px;
+                    -webkit-font-smoothing: antialiased;
+                    -moz-osx-font-smoothing: grayscale;
+                    text-rendering: optimizeLegibility;
+                    line-height: 1.5;
+                    font-size: 15.5px;
+                    color: #ECEFF4;
+                }
+
+                /* ... keep all your other typography / button / slider styles here ... */
+
+                .v-theme--dark { background-color: #14171C !important; color: #ECEFF4 !important; }
+                .v-theme--light { background-color: #F6F7FA !important; color: #1F1F1F !important; }
+
+                /* (rest of your .pfm-* classes unchanged) */
+                """)
+
+                # html.Style("""
+                # .v-theme--dark { background: #1F232B !important; }
+                # .v-theme--light { background: #f5f6f8 !important; }
+                # .v-theme--dark .pfm-card { background: #23272F !important; color: #fff !important; }
+                # .v-theme--light .pfm-card { background: #ffffff !important; color: #1f232b !important; }
+                # .v-theme--dark .pfm-viewer { background: #15171d !important; }
+                # .v-theme--light .pfm-viewer { background: #e9edf3 !important; }
+                # .pfm-card { border-radius: 16px !important; box-shadow: 0 6px 24px rgba(0,0,0,0.12); }
+                # .pfm-progress .v-progress-linear { height: 22px !important; border-radius: 999px !important; }
+                # .pfm-btn-big.v-btn {
+                #     height: 48px !important;
+                #     font-size: 18px !important;
+                #     font-weight: 600 !important;
+                #     letter-spacing: 1.2px;
+                #     text-transform: none !important;
+                #     border-radius: 999px !important;
+                # }
+                # .pfm-viewer { min-height: 420px; height: 650px !important; border-radius: 16px; }
+                # """)
+                html.Link(
+                    rel="stylesheet",
+                    href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;600&display=swap",
+                )
+
+                with v3.VThemeProvider(theme=("theme_dark ? 'dark' : 'light'",)):
+                    with v3.VContainer(
+                        fluid=True,
+                        class_="pa-6",
+                        style=(
+                            "max-width: 2200px;"                     # max width of content
+                            "margin: 8px auto 16px auto;"          # top / left-right / bottom
+                            "padding: 0 8px;"                      # inner left/right padding
+                            "box-sizing: border-box;"
+                            "background: rgba(255,255,255,0.02);"
+                            "border-radius: 16px;"
+                        ),
+                    ):
+
+
+                        # 1) Physics Application
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧪 <b>Physics Application</b>",
+                                style="font-size:28px;font-weight:700;letter-spacing:1.1px;margin-bottom:10px;",
+                            )
+                            html.Div(
+                                "Select the type of analysis",
+                                style="font-size:24px;opacity:.82;margin-bottom:18px;",
+                            )
+                            toggle = v3.VBtnToggle(
+                                v_model=("analysis_type", self.state.analysis_type),
+                                class_="mt-1",
+                                mandatory=True,
+                                rounded=True,
+                            )
+                            # with toggle:
+                            #     for at in ANALYSIS_TYPE:
+                            #         v3.VBtn(
+                            #             at,
+                            #             value=at,
+                            #             variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                            #             class_="mr-2 pfm-toggle-xxl",
+                            #         )
+
+                            with toggle:
+                                for at in ANALYSIS_TYPE:
+                                    v3.VBtn(
+                                        at,
+                                        value=at,
+                                        variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                                        class_="mr-2 pfm-toggle-xxl",
+                                        style=(
+                                            "font-size:18px;"
+                                            "font-weight:800;"
+                                            "letter-spacing:0.4px;"
+                                            "text-transform:none;"
+                                        ),
+                                    )
+
+                        # 2) Dataset + Variable
+                        with v3.VRow(dense=True, class_="mb-3"):
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "🧩 Sub Application",
+                                        style="font-weight:700;font-size:24px;margin-bottom:14px;",
+                                    )
+                                    v3.VSelect(
+                                        v_model=("dataset", self.state.dataset),
+                                        items=("dataset_choices", self.state.dataset_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        style=(
+                                            "font-size:24px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        class_="pfm-big-select-subapp",
+                                        menu_props={"content_class": "pfm-subapp-list"},  # <— key for dropdown items
+                                    )
+                                    # v3.VSelect(
+                                    #     v_model=("dataset", self.state.dataset),
+                                    #     items=("dataset_choices", self.state.dataset_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     class_="pfm-big-select-subapp pfm-subapp-list",
+                                    #     style="font-size:21px;",
+                                    # )
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "📊 Variable to Predict",
+                                        style="font-weight:700;font-size:20px;margin-bottom:14px;",
+                                    )
+
+                                    v3.VSelect(
+                                        v_model=("variable", self.state.variable),
+                                        items=("variable_choices", self.state.variable_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        class_="pfm-var-select",
+                                        style=(
+                                            "font-size:20px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        menu_props={"content_class": "pfm-var-list"},
+                                    )
+                                                                        # v3.VSelect(
+                                    #     v_model=("variable", self.state.variable),
+                                    #     items=("variable_choices", self.state.variable_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     style="font-size:16px;",
+                                    # )
+
+                        # 3) Boundary Conditions
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧱 Boundary Conditions",
+                                style="font-weight:700;font-size:22px;margin-bottom:16px;",
+                            )
+
+                            # two columns: Left = velocity controls, Right = reference text
+                            with v3.VRow(class_="align-start", dense=True):
+                                # ---- LEFT: velocity slider / readout ----
+                                with v3.VCol(cols=7, class_="pfm-vel"):
+                                    html.Div(
+                                        "🚗 Velocity (mph)",
+                                        class_="pfm-vel-title",
+                                        style="margin-bottom:8px;font-weight:800;font-size:21px;letter-spacing:.3px;",
+                                    )
+                                    html.Div(
+                                        "Set the inlet velocity in miles per hour",
+                                        class_="pfm-vel-sub",
+                                        style="margin-bottom:10px;font-size:20px;opacity:.95;",
+                                    )
+                                    v3.VSlider(
+                                        v_model=("velocity_mph", self.state.velocity_mph),
+                                        min=30.0, max=80.0, step=0.1,
+                                        thumb_label=True,
+                                        v_if=("show_velocity",),
+                                        style="height:54px;margin-top:12px;max-width:540px;",
+                                        class_="mt-3 mb-3 pfm-vel-slider",
+                                    )
+                                    html.Div(
+                                        "{{ velocity_mph.toFixed(0) }} / 80 "
+                                        "<span style='opacity:.95'>"
+                                        "({{ (velocity_mph * 0.44704).toFixed(2) }} m/s)</span>",
+                                        v_if=("show_velocity",),
+                                        class_="pfm-vel-readout",
+                                        style="font-size:18px;font-weight:900;letter-spacing:.3px;margin-top:6px;",
+                                    )
+
+                                # ---- RIGHT: fixed reference values (HTML from bc_text_right / bc_text_left) ----
+                                with v3.VCol(cols=5, class_="pfm-bc-right"):
+                                    html.Div(
+                                        v_html=("bc_text_html", ""),
+                                        style=(
+                                            "margin-top:6px;"
+                                            "font-size:18px;"
+                                            "line-height:1.7;"
+                                            "min-width:260px;"
+                                            "max-width:360px;"
+                                            "text-align:left;"
+                                        ),
+                                    )
+
+                        
+
+                        # 4) Two viewers
+                        with v3.VRow(style="margin-top: 24px;"):
+                            # LEFT = upload
+                            with v3.VCol(cols=6):
+                                with v3.VRow(class_="align-center justify-space-between mb-2"):
+                                    html.Div(
+                                        "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📤 Input Geometry</span>",
+                                    )
+
+                                    # ✅ working gear menu
+                                    with v3.VMenu(
+                                        location="bottom end",
+                                        close_on_content_click=False,
+                                        offset="4 8",
+                                    ):
+                                        # activator slot MUST expose { props } and we MUST bind them to the button
+                                        with v3.Template(v_slot_activator="{ props }"):
+                                            with v3.VBtn(
+                                                icon=True,
+                                                variant="text",
+                                                density="comfortable",
+                                                style="min-width:32px;",
+                                                v_bind="props",               # 👈 this is the key
+                                            ):
+                                                v3.VIcon("mdi-cog", size="22")
+
+                                        # menu content
+                                        with v3.VCard(class_="pa-4", style="min-width: 280px;"):
+                                            html.Div("<b>Mesh decimation</b>", class_="mb-3", style="font-size:14px;")
+
+                                            v3.VSwitch(
+                                                v_model=("decim_enable",),
+                                                label="Enable decimation",
+                                                inset=True,
+                                                hide_details=True,
+                                                class_="mb-4",
+                                            )
+
+                                            html.Div(
+                                                "Target reduction (fraction of faces to remove)",
+                                                class_="mb-1",
+                                                style="font-size:12px;color:#9ca3af;",
+                                            )
+                                            v3.VSlider(
+                                                v_model=("decim_target",),
+                                                min=0.0,
+                                                max=0.999,
+                                                step=0.001,
+                                                hide_details=True,
+                                                class_="mb-2",
+                                            )
+                                            html.Div("{{ decim_target.toFixed(3) }}", style="font-size:11px;", class_="mb-3")
+
+                                            with v3.VRow(dense=True, class_="mb-3"):
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Min faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_min_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Max faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_max_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+
+                                            v3.VBtn(
+                                                "Apply to current mesh",
+                                                block=True,
+                                                color="primary",
+                                                class_="mt-2",
+                                                click=self.decimate_again,
+                                            )
+
+                                            v3.VBtn(
+                                                "Reset to original mesh",
+                                                block=True,
+                                                variant="tonal",
+                                                class_="mt-2",
+                                                click=self.reset_mesh,       # 👈 will call the controller you added
+                                            )
+
+
+                                v3.VFileInput(
+                                    label="Select 3D File",
+                                    style="font-size:17px;padding:12px;height:50px;margin-bottom:20px;",
+                                    multiple=False,
+                                    show_size=True,
+                                    accept=".stl,.vtk,.vtp,.ply,.obj,.vtu,.glb",
+                                    v_model=("upload", None),
+                                    clearable=True,
+                                )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_geom = VtkRemoteView(
+                                        self.rw_geom,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                            rounded=True, elevation=3):
+                                    html.Div("<b>Upload</b>", style="font-size:18px;")
+
+                                    # progress bar: only while uploading
+                                    v3.VProgressLinear(
+                                        v_model=("pm_upload", 0),
+                                        height=22,
+                                        style="margin-top:10px;margin-bottom:10px;",
+                                        color="primary",
+                                        rounded=True,
+                                        v_show=("is_uploading",),   # 👈 bar disappears after upload
+                                    )
+
+                                    # text: percentage + time + message, only while uploading
+                                    html.Div(
+                                        "{{ pm_upload }}% — {{ pm_elapsed_upload.toFixed(2) }}s — {{ upload_msg }}",
+                                        style="font-size:14px;",
+                                        v_show=("is_uploading",),   # 👈 hide text after completion
+                                    )
+
+                                v3.VBtn(
+                                    "🗑️ CLEAR",
+                                    block=True,
+                                    variant="tonal",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.clear,
+                                )
+                            # RIGHT = prediction
+                            with v3.VCol(cols=6):
+                                html.Div(
+                                    "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📈 Prediction Results</span>",
+                                    style="margin-bottom:10px;",
+                                )
+                                html.Div(
+                                    v_html=("stats_html",),
+                                    class_="mb-3",
+                                    style="font-size:20px;line-height:1.4;",
+                                )
+                                # v3.VProgressLinear(
+                                #     v_model=("predict_progress", 0),
+                                #     height=22,
+                                #     style="margin-top:6px;margin-bottom:12px;",
+                                #     color="primary",
+                                #     rounded=True,
+                                #     indeterminate=("predict_progress < 10",),
+                                #     v_show=("is_predicting",),
+                                # )
+                                # html.Div(
+                                #     "Predicting: {{ predict_progress }}%",
+                                #     style="font-size:14px;margin-bottom:10px;",
+                                #     v_show=("is_predicting",),
+                                # )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_pred = VtkRemoteView(
+                                        self.rw_pred,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                            rounded=True, elevation=3):
+                                    html.Div("<b>Inference</b>", style="font-size:18px;")
+
+                                    # 🔴 OLD: v_model=("predict_progress", 0), indeterminate=...
+                                    # 🟢 NEW: use pm_infer and a normal (non-indeterminate) bar
+                                    v3.VProgressLinear(
+                                        v_model=("pm_infer", 0),
+                                        height=22,
+                                        style="margin-top:6px;margin-bottom:12px;",
+                                        color="success",
+                                        rounded=True,
+                                        indeterminate=("predict_progress <= 0",),
+                                        v_show=("is_predicting",),   # 👈 bar only visible while predicting
+                                    )
+
+                                    # text line: % + elapsed time + current stage message
+                                    html.Div(
+                                        "{{ pm_infer }}% — {{ pm_elapsed_infer.toFixed(2) }}s — {{ predict_msg }}",
+                                        style="font-size:14px;margin-bottom:10px;",
+                                        # ❗ if you want the *text* to also disappear at the end, keep v_show;
+                                        # if you want the final "✅ Prediction complete — 1.23s" to stay, REMOVE v_show
+                                        v_show=("is_predicting",),
+                                    )
+                                v3.VBtn(
+                                    "🚀 PREDICT",
+                                    block=True,
+                                    color="primary",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.predict,
+                                )
+
+            layout.on_ready = self._first_paint
+
+    def _first_paint(self, **_):
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+    # ---------------------------------------------------------
+    # UPLOAD (async)
+    # ---------------------------------------------------------
+    def _write_upload_to_disk(self, payload) -> str:
+        if payload is None:
+            raise ValueError("No file payload")
+        if isinstance(payload, (list, tuple)):
+            payload = payload[0]
+        if isinstance(payload, str):
+            return payload
+        if not isinstance(payload, dict):
+            raise ValueError(f"Unsupported payload: {type(payload)}")
+        if payload.get("path"):
+            return payload["path"]
+        name = payload.get("name") or "upload"
+        content = payload.get("content")
+        if isinstance(content, str) and content.startswith("data:"):
+            content = content.split(",", 1)[1]
+        raw = base64.b64decode(content) if isinstance(content, str) else bytes(content)
+        os.makedirs(GEOM_DIR, exist_ok=True)
+        file_path = os.path.join(GEOM_DIR, name)
+        with open(file_path, "wb") as f:
+            f.write(raw)
+        return file_path
+
+    def _pre_upload_spinner_loop(self):
+        s = self.state
+        phase = 1
+        while self._pre_upload_on and not self._upload_actual_started and s.is_uploading:
+            s.pm_upload = max(1, min(9, phase))
+            s.upload_msg = "Initializing upload..."
+            try:
+                self.server.state.flush()
+            except Exception:
+                pass
+            phase = 1 if phase >= 9 else phase + 1
+            time.sleep(0.15)
+
+    def _start_pre_upload_spinner(self):
+        if self._pre_upload_thread and self._pre_upload_thread.is_alive():
+            return
+        self._upload_actual_started = False
+        self._pre_upload_on = True
+        self._pre_upload_thread = threading.Thread(
+            target=self._pre_upload_spinner_loop, daemon=True
+        )
+        self._pre_upload_thread.start()
+
+    def _stop_pre_upload_spinner(self):
+        self._pre_upload_on = False
+        self._pre_upload_thread = None
+
+    async def _fake_upload_bump(self, stop_event: asyncio.Event):
+        s = self.state
+        while not stop_event.is_set() and s.pm_upload < 9:
+            s.pm_upload += 1
+            await self._flush_async()
+            await asyncio.sleep(0.05)
+
+    async def _upload_worker_async(self, upload):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        s.is_uploading = True
+        s.upload_msg = "Starting upload..."
+        s.pm_elapsed_upload = 0.0
+
+        s.pm_upload = 5
+        self.server.state.flush()
+        await asyncio.sleep(0)
+
+        fake_stop = asyncio.Event()
+        fake_task = asyncio.create_task(self._fake_upload_bump(fake_stop))
+
+        try:
+            self._upload_actual_started = True
+            self._stop_pre_upload_spinner()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+                try:
+                    await fake_task
+                except asyncio.CancelledError:
+                    pass
+
+            s.upload_msg = "Writing file to disk..."
+            s.pm_upload = 10
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            file_path = await loop.run_in_executor(None, self._write_upload_to_disk, upload)
+
+            s.upload_msg = "Reading mesh..."
+            s.pm_upload = 20
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            mesh = await loop.run_in_executor(None, pv.read, file_path)
+
+            # 3) decimation (auto first)
+            try:
+                nf = poly_count(mesh)
+            except Exception:
+                nf = mesh.n_cells
+
+            auto_tr = float(auto_target_reduction(nf))
+
+            # reflect auto in UI
+            s.decim_target = auto_tr
+            s.decim_min_faces = 5000            # <= allow decimation even for 27k faces
+            s.decim_max_faces = int(1e7)
+
+            target = auto_tr
+            min_faces = 5000
+            max_faces = int(1e7)
+
+            # user override
+            if self.state.decim_enable:
+                target = float(self.state.decim_target or 0.0)
+                min_faces = int(self.state.decim_min_faces or 5000)
+                max_faces = int(self.state.decim_max_faces or 1e7)
+
+            if target > 0.0:
+                s.upload_msg = f"Decimating mesh ({target:.3f})..."
+                s.pm_upload = max(s.pm_upload, 45)
+                s.pm_elapsed_upload = time.time() - t0
+                await self._flush_async()
+
+                dec_cfg = {
+                    "enabled": True,
+                    "method": "pro",
+                    "target_reduction": target,
+                    "min_faces": min_faces,
+                    "max_faces": max_faces,
+                }
+                mesh = await loop.run_in_executor(None, decimate_mesh, mesh, dec_cfg)
+
+            # 4) normals + save
+            s.upload_msg = "Preparing geometry..."
+            s.pm_upload = 75
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            def _normals_and_save(m):
+                m_fixed = m.compute_normals(
+                    consistent_normals=True,
+                    auto_orient_normals=True,
+                    point_normals=True,
+                    cell_normals=False,
+                    inplace=False,
+                )
+                geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+                m_fixed.save(geom_path_)
+                return geom_path_, m_fixed
+
+            geom_path, mesh_fixed = await loop.run_in_executor(None, _normals_and_save, mesh)
+
+            # 5) update viewer
+            self.ren_geom.RemoveAllViewProps()
+            self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+            self.ren_geom.ResetCamera()
+            try:
+                self.rw_geom.Render()
+            except Exception:
+                pass
+            self.view_geom.update()
+            # GEOMETRY_CACHE.current_mesh = mesh_fixed
+            GEOMETRY_CACHE.original_mesh = mesh_fixed.copy(deep=True)
+            GEOMETRY_CACHE.current_mesh = mesh_fixed
+
+            s.upload_msg = "✅ Geometry ready."
+            s.pm_upload = 100
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+        except Exception as e:
+            s.upload_msg = f"❌ Upload failed: {e}"
+            s.pm_upload = 0
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+        finally:
+            s.is_uploading = False
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+            if not fake_task.done():
+                fake_task.cancel()
+                try:
+                    await fake_task
+                except Exception:
+                    pass
+
+    @change("upload")
+    def _on_upload_change(self, upload, **_):
+        if not upload:
+            return
+        self._run_coro(self._upload_worker_async(upload))
+
+    def decimate_again(self):
+        self._run_coro(self._decimate_again_async())
+
+    async def _decimate_again_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            # nothing to decimate
+            s.upload_msg = "No mesh to re-decimate"
+            await self._flush_async()
+            return
+
+        # --- start "upload-like" progress for manual decimation ---
+        t0 = time.time()
+        s.is_uploading = True
+        s.pm_upload = 5
+        s.pm_elapsed_upload = 0.0
+        s.upload_msg = "Starting mesh re-decimation..."
+        await self._flush_async()
+
+        try:
+            # read parameters from UI
+            try:
+                target = float(s.decim_target)
+            except Exception:
+                target = 0.0
+
+            try:
+                min_faces = int(s.decim_min_faces)
+            except Exception:
+                min_faces = 5000
+
+            try:
+                max_faces = int(s.decim_max_faces)
+            except Exception:
+                max_faces = int(1e7)
+
+            if (not s.decim_enable) or target <= 0.0:
+                s.upload_msg = "Decimation disabled"
+                s.pm_upload = 0
+                s.pm_elapsed_upload = time.time() - t0
+                await self._flush_async()
+                return
+
+            # --- bump before heavy decimation call ---
+            s.upload_msg = f"Re-decimating mesh ({target:.3f})..."
+            s.pm_upload = 25
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            dec_cfg = {
+                "enabled": True,
+                "method": "pro",
+                "target_reduction": target,
+                "min_faces": min_faces,
+                "max_faces": max_faces,
+            }
+
+            # heavy work on executor
+            mesh = await loop.run_in_executor(
+                None, decimate_mesh, GEOMETRY_CACHE.current_mesh, dec_cfg
+            )
+
+            # --- normals + save ---
+            s.upload_msg = "Recomputing normals & saving..."
+            s.pm_upload = 70
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            def _normals_and_save(m):
+                m_fixed = m.compute_normals(
+                    consistent_normals=True,
+                    auto_orient_normals=True,
+                    point_normals=True,
+                    cell_normals=False,
+                    inplace=False,
+                )
+                geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+                m_fixed.save(geom_path_)
+                return geom_path_, m_fixed
+
+            geom_path, mesh_fixed = await loop.run_in_executor(
+                None, _normals_and_save, mesh
+            )
+
+            # --- update viewer ---
+            s.upload_msg = "Updating viewer..."
+            s.pm_upload = 90
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            self.ren_geom.RemoveAllViewProps()
+            self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+            self.ren_geom.ResetCamera()
+            try:
+                self.rw_geom.Render()
+            except Exception:
+                pass
+            self.view_geom.update()
+
+            GEOMETRY_CACHE.current_mesh = mesh_fixed
+
+            # --- final bump ---
+            s.upload_msg = "✅ Re-decimated"
+            s.pm_upload = 100
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+        except Exception as e:
+            s.upload_msg = f"❌ Re-decimation failed: {e}"
+            s.pm_upload = 0
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+        finally:
+            # hide bar + text after we’re done
+            s.is_uploading = False
+            await self._flush_async()
+
+
+    def reset_mesh(self):
+        self._run_coro(self._reset_mesh_async())
+
+    async def _reset_mesh_async(self):
+        s = self.state
+
+        if GEOMETRY_CACHE.original_mesh is None:
+            s.upload_msg = "No original mesh to reset to"
+            await self._flush_async()
+            return
+
+        # use the saved original
+        orig = GEOMETRY_CACHE.original_mesh
+
+        # save it again as current
+        GEOMETRY_CACHE.current_mesh = orig
+
+        # write to disk (so the STL on disk matches the viewer)
+        geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+        orig.save(geom_path)
+
+        # update viewer
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+        self.ren_geom.ResetCamera()
+        try:
+            self.rw_geom.Render()
+        except Exception:
+            pass
+        self.view_geom.update()
+
+        s.upload_msg = "↩️ Reset to original mesh"
+        await self._flush_async()
+
+    # ---------------------------------------------------------
+    # prediction
+    # ---------------------------------------------------------
+    def _start_infer_heartbeat(self):
+        if self._infer_thread and self._infer_thread.is_alive():
+            return
+
+        def loop_fn():
+            while self._infer_heartbeat_on:
+                if self.state.is_predicting and self._predict_t0 is not None:
+                    self.state.pm_elapsed_infer = max(0.0, time.time() - self._predict_t0)
+                    try:
+                        self.server.state.flush()
+                    except Exception:
+                        pass
+                time.sleep(0.12)
+
+        self._infer_heartbeat_on = True
+        self._infer_thread = threading.Thread(target=loop_fn, daemon=True)
+        self._infer_thread.start()
+
+    def _stop_infer_heartbeat(self):
+        self._infer_heartbeat_on = False
+        self._infer_thread = None
+
+    async def _predict_worker_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            s.predict_msg = "❌ Please upload geometry first"
+            s.is_predicting = False
+            await self._flush_async()
+            return
+
+        s.is_predicting = True
+        s.predict_progress = 1
+        s.pm_infer = 1
+        s.predict_msg = "Preparing inference..."
+        self._predict_t0 = time.time()
+        self._start_infer_heartbeat()
+        await self._flush_async()
+
+        try:
+            dataset = s.dataset
+            variable = s.variable
+            boundary = (
+                {"freestream_velocity": mph_to_ms(s.velocity_mph)}
+                if dataset == "Incompressible flow over car"
+                else None
+            )
+
+            s.predict_msg = "Loading model/checkpoint..."
+            s.predict_progress = 5
+            s.pm_infer = 5
+            await self._flush_async()
+
+            cfg, model, device, _ = await loop.run_in_executor(
+                None, MODEL_STORE.get, dataset, variable, None
+            )
+
+            s.predict_msg = "Processing mesh for inference..."
+            s.predict_progress = 35
+            s.pm_infer = 35
+            await self._flush_async()
+
+            def _run_full():
+                return run_inference_fast(
+                    dataset,
+                    variable,
+                    boundary_conditions=boundary,
+                    progress_cb=None,
+                )
+            viz = await loop.run_in_executor(None, _run_full)
+
+            s.predict_msg = "Preparing visualization..."
+            s.predict_progress = 85
+            s.pm_infer = 85
+            await self._flush_async()
+
+            stl_path = os.path.join(GEOM_DIR, "geometry.stl")
+            vmin = float(np.min(viz["pred"]))
+            vmax = float(np.max(viz["pred"]))
+
+            if os.path.exists(stl_path):
+                _tmp_trimesh, vmin, vmax = create_visualization_stl(viz, stl_path)
+                lut = build_jet_lut(vmin, vmax)
+                colored_actor = color_actor_with_scalars_from_prediction(
+                    stl_path,
+                    viz["points"],
+                    viz["pred"],
+                    variable,
+                    vmin,
+                    vmax,
+                    lut=lut,
+                )
+                self.ren_pred.AddActor(colored_actor)
+
+                units = {
+                    "pressure": "Pa",
+                    "x_velocity": "m/s",
+                    "y_velocity": "m/s",
+                    "z_velocity": "m/s",
+                }.get(variable, "")
+                title = f"{variable} ({units})" if units else variable
+                self.scalar_bar = add_or_update_scalar_bar(
+                    self.ren_pred, lut, title, label_fmt="%-0.2f", n_labels=8
+                )
+
+                src_cam = self.ren_geom.GetActiveCamera()
+                dst_cam = self.ren_pred.GetActiveCamera()
+                if src_cam is not None and dst_cam is not None:
+                    dst_cam.SetPosition(src_cam.GetPosition())
+                    dst_cam.SetFocalPoint(src_cam.GetFocalPoint())
+                    dst_cam.SetViewUp(src_cam.GetViewUp())
+                    dst_cam.SetParallelScale(src_cam.GetParallelScale())
+                    cr = src_cam.GetClippingRange()
+                    dst_cam.SetClippingRange(cr)
+
+                try:
+                    self.rw_pred.Render()
+                except Exception:
+                    pass
+                self.view_pred.update()
+
+            raw_vmin = float(np.min(viz["pred"]))
+            raw_vmax = float(np.max(viz["pred"]))
+
+            s.stats_html = (
+                f"<b>{variable} min:</b>{raw_vmin:.3e} "
+                f"<b>max:</b> {raw_vmax:.3e} "
+                f"<b>Confidence:</b> {viz['confidence_score']:.4f}"
+            )
+
+            s.predict_msg = "✅ Prediction complete."
+            s.predict_progress = 100
+            s.pm_infer = 100
+            s.predict_elapsed = time.time() - t0
+            s.pm_elapsed_infer = s.predict_elapsed
+            await self._flush_async()
+
+        except Exception as e:
+            s.predict_msg = f"❌ Prediction failed: {e}"
+            s.predict_progress = 0
+            s.pm_infer = 0
+            await self._flush_async()
+        finally:
+            s.is_predicting = False
+            self._stop_infer_heartbeat()
+            await self._flush_async()
+
+    @time_function("Inference and Visualization")
+    def predict(self, *_):
+        self._run_coro(self._predict_worker_async())
+
+    # ---------------------------------------------------------
+    # dataset wiring
+    # ---------------------------------------------------------
+    @change("analysis_type")
+    def _on_analysis_type_change(self, analysis_type=None, **_):
+        ds_list = ANALYSIS_TYPE_MAPPING.get(analysis_type or "", [])
+        default_ds = ds_list[0] if ds_list else None
+        self.state.dataset_choices = ds_list
+        if default_ds and self.state.dataset != default_ds:
+            self.state.dataset = default_ds
+        elif self.state.dataset:
+            self._apply_dataset(self.state.dataset)
+
+    @change("dataset")
+    def _on_dataset_change(self, dataset=None, **_):
+        if not dataset:
+            return
+        self._apply_dataset(dataset)
+
+    def _apply_dataset(self, ds: str):
+        s = self.state
+        opts = variables_for(ds) if ds else []
+        s.variable_choices = opts
+        s.variable = opts[0] if opts else None
+
+        s.show_velocity = (ds == "Incompressible flow over car")
+        s.is_plane = (ds == "Compressible flow over plane")
+
+        s.bc_text = get_boundary_conditions_text(ds)
+        s.bc_left = bc_text_left(ds)
+        s.bc_right = bc_text_right(ds)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+    # ---------------------------------------------------------
+    # clear
+    # ---------------------------------------------------------
+    def clear(self, *_):
+        for d in [GEOM_DIR, SOLN_DIR]:
+            if os.path.exists(d):
+                shutil.rmtree(d)
+            os.makedirs(d, exist_ok=True)
+        s = self.state
+        s.stats_html = "🧹 Cleared. Upload again."
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.upload_msg = ""
+        s.pm_elapsed_upload = 0.0
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_pred.RemoveAllViewProps()
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+# ---------- main ----------
+def main():
+    app = PFMDemo()
+    app.server.controller.add("decimate_again", app.decimate_again)
+    app.server.controller.add("reset_mesh", app.reset_mesh)
+    app.server.start(7872)
+
+if __name__ == "__main__":
+    main()

README.md

@@ -0,0 +1,8 @@
+title: AnsysLPFM App
+emoji: 💻
+colorFrom: yellow
+colorTo: gray
+sdk: docker
+pinned: false
+license: mit
+short_description: Ansys Research for Foundation models on physics

ULIP

@@ -0,0 +1 @@
+Subproject commit 5e7c0da470fc16717030ec4116b0f81d4d2b4823

app.py

@@ -0,0 +1,1766 @@
+# ========= Headless / Offscreen safety (before any VTK import) =========
+import os
+os.environ.setdefault("VTK_DEFAULT_RENDER_WINDOW_OFFSCREEN", "1")
+os.environ.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+os.environ.setdefault("MESA_LOADER_DRIVER_OVERRIDE", "llvmpipe")
+os.environ.setdefault("MESA_GL_VERSION_OVERRIDE", "3.3")
+os.environ.setdefault("DISPLAY", "")
+
+# ========= Core setup =========
+import shutil, time, tempfile, json, base64, threading, re, html as _html, asyncio
+import numpy as np
+import torch
+import pyvista as pv
+from scipy.spatial import cKDTree
+from vtk.util import numpy_support as nps
+import matplotlib.cm as cm
+
+from omegaconf import OmegaConf
+from huggingface_hub import hf_hub_download
+from accelerate import Accelerator
+from accelerate.utils import DistributedDataParallelKwargs
+import pickle
+from sklearn.metrics import pairwise_distances
+from train import get_single_latent
+from sklearn.neighbors import NearestNeighbors
+
+from utils.app_utils2 import (
+    create_visualization_points,
+    create_visualization_stl,
+    camera_from_bounds,
+    bounds_from_points,
+    convert_vtp_to_glb,
+    convert_vtp_to_stl,
+    time_function,
+    print_timing,
+    mesh_get_variable,
+    mph_to_ms,
+    get_boundary_conditions_text,
+    compute_confidence_score,
+    compute_cosine_score,
+    decimate_mesh,
+)
+
+# ========= trame =========
+from trame.app import TrameApp
+from trame.decorators import change
+from trame.ui.vuetify3 import SinglePageLayout
+from trame.widgets import vuetify3 as v3, html
+from trame_vtk.widgets.vtk import VtkRemoteView
+
+# ========= VTK =========
+from vtkmodules.vtkRenderingCore import (
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkPolyDataMapper,
+    vtkActor,
+    vtkRenderWindowInteractor,
+)
+from vtkmodules.vtkRenderingAnnotation import vtkScalarBarActor
+from vtkmodules.vtkIOGeometry import vtkSTLReader
+from vtkmodules.vtkFiltersCore import vtkTriangleFilter
+from vtkmodules.vtkCommonCore import vtkLookupTable
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+
+# ========= Writable paths / caches =========
+DATA_DIR = os.path.join(tempfile.gettempdir(), "appdata")
+os.makedirs(DATA_DIR, exist_ok=True)
+os.environ.setdefault("MPLCONFIGDIR", DATA_DIR)
+
+GEOM_DIR = os.path.join(DATA_DIR, "geometry")
+SOLN_DIR = os.path.join(DATA_DIR, "solution")
+WEIGHTS_DIR = os.path.join(DATA_DIR, "weights")
+for d in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR):
+    os.makedirs(d, exist_ok=True)
+
+HF_DIR = os.path.join(DATA_DIR, "hf_home")
+os.environ.setdefault("HF_HOME", HF_DIR)
+os.environ.setdefault("HUGGINGFACE_HUB_CACHE", HF_DIR)
+os.environ.setdefault("TRANSFORMERS_CACHE", HF_DIR)
+os.makedirs(HF_DIR, exist_ok=True)
+for p in (GEOM_DIR, SOLN_DIR, WEIGHTS_DIR, HF_DIR):
+    if not os.access(p, os.W_OK):
+        raise RuntimeError(f"Not writable: {p}")
+
+# ========= Auto-decimation ladder =========
+def auto_target_reduction(num_cells: int) -> float:
+    if num_cells <= 10_000:
+        return 0.0
+    elif num_cells <= 20_000:
+        return 0.2
+    elif num_cells <= 50_000:
+        return 0.4
+    elif num_cells <= 100_000:
+        return 0.5
+    elif num_cells <= 500_000:
+        return 0.6
+    elif num_cells < 1_000_000:
+        return 0.8
+    else:
+        return 0.9
+
+# ========= Registry / choices =========
+REGISTRY = {
+    "Incompressible flow inside artery": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow inside artery/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_artery.pt"},
+        "out_variable": ["pressure", "x_velocity", "y_velocity", "z_velocity"],
+    },
+    "Vehicle crash analysis": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Vehicle crash analysis/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_vehiclecrash.pt"},
+        "out_variable": [
+            "impact_force",
+            "deformation",
+            "energy_absorption",
+            "x_displacement",
+            "y_displacement",
+            "z_displacement",
+        ],
+    },
+    "Compressible flow over plane": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Compressible flow over plane/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_plane_transonic_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+    "Incompressible flow over car": {
+        "repo_id": "ansysresearch/pretrained_models",
+        "config": "configs/app_configs/Incompressible flow over car/config.yaml",
+        "model_attr": "ansysLPFMs",
+        "checkpoints": {"best_val": "ckpt_cadillac_v3.pt"},
+        "out_variable": ["pressure"],
+    },
+}
+
+def variables_for(dataset: str):
+    spec = REGISTRY.get(dataset, {})
+    ov = spec.get("out_variable")
+    if isinstance(ov, str):
+        return [ov]
+    if isinstance(ov, (list, tuple)):
+        return list(ov)
+    return list(spec.get("checkpoints", {}).keys())
+
+ANALYSIS_TYPE_MAPPING = {
+    "External flow": ["Incompressible flow over car", "Compressible flow over plane"],
+    "Internal flow": ["Incompressible flow inside artery"],
+    "Crash analysis": ["Vehicle crash analysis"],
+}
+ANALYSIS_TYPE = list(ANALYSIS_TYPE_MAPPING.keys())
+DEFAULT_ANALYSIS_TYPE = "External flow"
+DEFAULT_DATASET = "Incompressible flow over car"
+VAR_CHOICES0 = variables_for(DEFAULT_DATASET)
+DEFAULT_VARIABLE = VAR_CHOICES0[0] if VAR_CHOICES0 else None
+
+# ========= Simple cache =========
+class GeometryCache:
+    def __init__(self):
+        self.original_mesh = None   # uploaded, cleaned (normals), BEFORE user re-decimation
+        self.current_mesh = None    # what the app is actually using right now
+
+GEOMETRY_CACHE = GeometryCache()
+
+# ========= Model store =========
+class ModelStore:
+    def __init__(self):
+        self._cache = {}
+
+    def _build(self, dataset: str, progress_cb=None):
+        def tick(x):
+            if progress_cb:
+                try:
+                    progress_cb(int(x))
+                except:
+                    pass
+
+        if dataset in self._cache:
+            tick(12)
+            return self._cache[dataset]
+
+        print(f"🔧 Building model for {dataset}")
+        start_time = time.time()
+        try:
+            spec = REGISTRY[dataset]
+            repo_id = spec["repo_id"]
+            ckpt_name = spec["checkpoints"]["best_val"]
+
+            tick(6)
+            t0 = time.time()
+            ckpt_path_hf = hf_hub_download(
+                repo_id=repo_id,
+                filename=ckpt_name,
+                repo_type="model",
+                local_dir=HF_DIR,
+                local_dir_use_symlinks=False,
+            )
+            print_timing("Model checkpoint download", t0)
+            tick(8)
+
+            t0 = time.time()
+            ckpt_local_dir = os.path.join(WEIGHTS_DIR, dataset)
+            os.makedirs(ckpt_local_dir, exist_ok=True)
+            ckpt_path = os.path.join(ckpt_local_dir, ckpt_name)
+            if not os.path.exists(ckpt_path):
+                shutil.copy(ckpt_path_hf, ckpt_path)
+            print_timing("Local model copy setup", t0)
+            tick(9)
+
+            t0 = time.time()
+            cfg_path = spec["config"]
+            if not os.path.exists(cfg_path):
+                raise FileNotFoundError(f"Missing config: {cfg_path}")
+            cfg = OmegaConf.load(cfg_path)
+            cfg.save_latent = True
+            print_timing("Configuration loading", t0)
+            tick(11)
+
+            t0 = time.time()
+            os.environ["CUDA_VISIBLE_DEVICES"] = str(getattr(cfg, "gpu_id", 0))
+            ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+            accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            print_timing("Device init", t0)
+            tick(12)
+
+            t0 = time.time()
+            import models
+            model_cls_name = spec["model_attr"]
+            if not hasattr(models, model_cls_name):
+                raise ValueError(f"Model '{model_cls_name}' not found")
+            model = getattr(models, model_cls_name)(cfg).to(device)
+            print_timing("Model build", t0)
+            tick(14)
+
+            t0 = time.time()
+            state = torch.load(ckpt_path, map_location=device)
+            model.load_state_dict(state)
+            model.eval()
+            print_timing("Weights load", t0)
+            tick(15)
+
+            result = (cfg, model, device, accelerator)
+            self._cache[dataset] = result
+            print_timing(f"Total model build for {dataset}", start_time)
+            return result
+        except Exception as e:
+            print_timing(f"Model build failed for {dataset}", e)
+            raise RuntimeError(f"Failed to load model for dataset '{dataset}': {e}")
+
+    def get(self, dataset: str, variable: str, progress_cb=None):
+        return self._build(dataset, progress_cb=progress_cb)
+
+MODEL_STORE = ModelStore()
+
+# ========= Inference pipeline =========
+def _variable_index(dataset: str, variable: str) -> int:
+    ov = REGISTRY[dataset]["out_variable"]
+    return 0 if isinstance(ov, str) else ov.index(variable)
+
+@time_function("Mesh Processing")
+def process_mesh_fast(mesh: pv.DataSet, cfg, variable, dataset, boundary_conditions=None):
+    jpath = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+    json_data = json.load(open(jpath, "r"))
+
+    pts = np.asarray(mesh.points, dtype=np.float32)
+    N = pts.shape[0]
+    rng = np.random.default_rng(42)
+    idx = rng.permutation(N)
+    points = pts[idx]
+    tgt_np = mesh_get_variable(mesh, variable, N)[idx]
+    pos = torch.from_numpy(points)
+    target = torch.from_numpy(tgt_np).unsqueeze(-1)
+
+    if getattr(cfg, "diff_input_velocity", False) and boundary_conditions is not None:
+        if "freestream_velocity" in boundary_conditions:
+            inlet_x_velocity = torch.tensor(boundary_conditions["freestream_velocity"]).float().reshape(1, 1)
+            inlet_x_velocity = inlet_x_velocity.repeat(N, 1)[idx]
+            pos = torch.cat((pos, inlet_x_velocity), dim=1)
+
+    if getattr(cfg, "input_normalization", None) == "shift_axis":
+        coords = pos[:, :3].clone()
+        coords[:, 0] = coords[:, 0] - coords[:, 0].min()
+        coords[:, 2] = coords[:, 2] - coords[:, 2].min()
+        y_center = (coords[:, 1].max() + coords[:, 1].min()) / 2.0
+        coords[:, 1] = coords[:, 1] - y_center
+        pos[:, :3] = coords
+
+    if getattr(cfg, "pos_embed_sincos", False):
+        mins = torch.tensor(json_data["mesh_stats"]["min"], dtype=torch.float32)
+        maxs = torch.tensor(json_data["mesh_stats"]["max"], dtype=torch.float32)
+        pos = 1000.0 * (pos - mins) / (maxs - mins)
+        pos = torch.clamp(pos, 0, 1000)
+
+    cosine_score = compute_cosine_score(mesh, dataset)
+    return pos, target, points, cosine_score
+
+@time_function("Inference")
+def run_inference_fast(dataset: str, variable: str, boundary_conditions=None, progress_cb=None):
+    def p(v):
+        if progress_cb:
+            try:
+                progress_cb(int(v))
+            except Exception:
+                pass
+
+    if GEOMETRY_CACHE.current_mesh is None:
+        raise ValueError("No geometry loaded")
+
+    p(5)
+    cfg, model, device, _ = MODEL_STORE.get(dataset, variable, progress_cb=p)
+    p(15)
+
+    pos, target, points, cosine_score = process_mesh_fast(
+        GEOMETRY_CACHE.current_mesh, cfg, variable, dataset, boundary_conditions
+    )
+    p(25)
+
+    confidence_score = 0.0
+    try:
+        if dataset not in ["Incompressible flow inside artery"]:
+            geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+            latent_features = get_single_latent(
+                mesh_path=geom_path,
+                config_path=os.path.join("configs/app_configs/", dataset, "config.yaml"),
+                device=device,
+                custom_velocity=boundary_conditions["freestream_velocity"] if boundary_conditions else None,
+                use_training_velocity=False,
+                model=model,
+            )
+
+            embedding_path = os.path.join("configs/app_configs/", dataset, "pca_embedding.npy")
+            pca_reducer_path = os.path.join("configs/app_configs/", dataset, "pca_reducer.pkl")
+            scaler_path = os.path.join("configs/app_configs/", dataset, "pca_scaler.pkl")
+
+            embedding = np.load(embedding_path)
+            pca_reducer = pickle.load(open(pca_reducer_path, "rb"))
+            scaler = pickle.load(open(scaler_path, "rb"))
+
+            train_pair_dists = pairwise_distances(embedding)
+            sigma = float(np.median(train_pair_dists)) if train_pair_dists.size > 0 else 1.0
+
+            n_points, n_features = latent_features.shape
+            np.random.seed(42)
+            target_len = int(pca_reducer.n_features_in_ / 256)
+            if n_points > target_len:
+                latent_features = latent_features[np.random.choice(n_points, target_len, replace=False)]
+            elif n_points < target_len:
+                num_extra = target_len - n_points
+                extra_indices = np.random.choice(n_points, num_extra, replace=True)
+                latent_features = np.vstack([latent_features, latent_features[extra_indices]])
+
+            latent_features = latent_features.flatten()
+
+            confidence_score = compute_confidence_score(
+                latent_features, embedding, scaler, pca_reducer, sigma
+            )
+    except Exception:
+        confidence_score = 0.0
+
+    data = {
+        "input_pos": pos.unsqueeze(0).to(device),
+        "output_feat": target.unsqueeze(0).to(device),
+    }
+
+    with torch.no_grad():
+        inp = data["input_pos"]
+        _, N, _ = inp.shape
+        chunk = int(getattr(cfg, "num_points", 10000))
+
+        if getattr(cfg, "chunked_eval", False) and chunk < N:
+            input_pos = data["input_pos"]
+            chunk_size = cfg.num_points
+            out_chunks = []
+            total = (N + chunk_size - 1) // chunk_size
+
+            for k, i in enumerate(range(0, N, chunk_size)):
+                ch = input_pos[:, i : i + chunk_size, :]
+                n_valid = ch.shape[1]
+
+                if n_valid < chunk_size:
+                    pad = input_pos[:, : chunk_size - n_valid, :]
+                    ch = torch.cat([ch, pad], dim=1)
+
+                data["input_pos"] = ch
+                out_chunk = model(data)
+                if isinstance(out_chunk, (tuple, list)):
+                    out_chunk = out_chunk[0]
+                out_chunks.append(out_chunk[:, :n_valid, :])
+
+                p(25 + 60 * (k + 1) / max(1, total))
+
+            outputs = torch.cat(out_chunks, dim=1)
+
+        else:
+            p(40)
+            outputs = model(data)
+            if isinstance(outputs, (tuple, list)):
+                outputs = outputs[0]
+            if torch.cuda.is_available():
+                torch.cuda.synchronize()
+            p(85)
+
+    vi = _variable_index(dataset, variable)
+    pred = outputs[0, :, vi : vi + 1]
+
+    if getattr(cfg, "normalization", "") == "std_norm":
+        fp = os.path.join("configs/app_configs/", dataset, "full_transform_params.json")
+        j = json.load(open(fp, "r"))
+        mu = torch.tensor(float(j["scalars"][variable]["mean"]), device=pred.device)
+        sd = torch.tensor(float(j["scalars"][variable]["std"]), device=pred.device)
+        pred = pred * sd + mu
+
+    pred_np = pred.squeeze().detach().cpu().numpy()
+    tgt_np = target.squeeze().numpy()
+
+    pred_t = torch.from_numpy(pred_np).unsqueeze(-1)
+    tgt_t = torch.from_numpy(tgt_np).unsqueeze(-1)
+    rel_l2 = torch.mean(
+        torch.norm(pred_t.squeeze(-1) - tgt_t.squeeze(-1), p=2, dim=-1)
+        / torch.norm(tgt_t.squeeze(-1), p=2, dim=-1)
+    )
+    tgt_mean = torch.mean(tgt_t)
+    ss_tot = torch.sum((tgt_t - tgt_mean) ** 2)
+    ss_res = torch.sum((tgt_t - pred_t) ** 2)
+    r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else torch.tensor(0.0)
+
+    p(100)
+    return {
+        "points": np.asarray(points),
+        "pred": np.asarray(pred_np),
+        "tgt": np.asarray(tgt_np),
+        "cosine_score": float(cosine_score),
+        "confidence_score": float(confidence_score),
+        "abs_err": float(np.mean(np.abs(pred_np - tgt_np))),
+        "mse_err": float(np.mean((pred_np - tgt_np) ** 2)),
+        "rel_l2": float(rel_l2.item()),
+        "r_squared": float(r2.item()),
+    }
+
+# ========= VTK helpers =========
+def make_actor_from_stl(stl_path: str, color=(0.85, 0.85, 0.85)):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    tri = vtkTriangleFilter()
+    tri.SetInputConnection(r.GetOutputPort())
+    tri.Update()
+    m = vtkPolyDataMapper()
+    m.SetInputConnection(tri.GetOutputPort())
+    a = vtkActor()
+    a.SetMapper(m)
+    a.GetProperty().SetColor(*color)
+    return a
+
+def build_jet_lut(vmin, vmax):
+    lut = vtkLookupTable()
+    lut.SetRange(float(vmin), float(vmax))
+    lut.SetNumberOfTableValues(256)
+    lut.Build()
+    cmap = cm.get_cmap("jet", 256)
+    for i in range(256):
+        r_, g_, b_, _ = cmap(i)
+        lut.SetTableValue(i, float(r_), float(g_), float(b_), 1.0)
+    return lut
+
+def color_actor_with_scalars_from_prediction(stl_path, points_xyz, pred_vals, array_name, vmin, vmax, lut=None):
+    r = vtkSTLReader()
+    r.SetFileName(stl_path)
+    r.Update()
+    poly = r.GetOutput()
+
+    stl_pts = nps.vtk_to_numpy(poly.GetPoints().GetData())
+    tree = cKDTree(points_xyz)
+    _, nn_idx = tree.query(stl_pts, k=1)
+    scalars = np.asarray(pred_vals, dtype=np.float32)[nn_idx]
+
+    vtk_arr = nps.numpy_to_vtk(scalars, deep=True)
+    vtk_arr.SetName(array_name)
+    poly.GetPointData().AddArray(vtk_arr)
+    poly.GetPointData().SetActiveScalars(array_name)
+
+    mapper = vtkPolyDataMapper()
+    mapper.SetInputData(poly)
+    mapper.SetScalarModeToUsePointData()
+    mapper.ScalarVisibilityOn()
+    mapper.SetScalarRange(float(vmin), float(vmax))
+    if lut is None:
+        lut = build_jet_lut(vmin, vmax)
+    mapper.SetLookupTable(lut)
+    mapper.UseLookupTableScalarRangeOn()
+
+    actor = vtkActor()
+    actor.SetMapper(mapper)
+    return actor
+
+def add_or_update_scalar_bar(renderer, lut, title, label_fmt="%-0.2f", n_labels=8):
+    existing = []
+    ca = renderer.GetActors2D()
+    ca.InitTraversal()
+    for _ in range(ca.GetNumberOfItems()):
+        a = ca.GetNextItem()
+        if isinstance(a, vtkScalarBarActor):
+            existing.append(a)
+    for a in existing:
+        renderer.RemoveActor2D(a)
+
+    sbar = vtkScalarBarActor()
+    sbar.SetLookupTable(lut)
+    sbar.SetOrientationToVertical()
+    sbar.SetLabelFormat(label_fmt)
+    sbar.SetNumberOfLabels(int(n_labels))
+    sbar.SetTitle(title)
+    sbar.SetPosition(0.92, 0.05)
+    sbar.SetPosition2(0.06, 0.90)
+
+    tp = sbar.GetTitleTextProperty()
+    tp.SetColor(1, 1, 1)
+    tp.SetBold(True)
+    tp.SetFontSize(22)
+    lp = sbar.GetLabelTextProperty()
+    lp.SetColor(1, 1, 1)
+    lp.SetFontSize(18)
+
+    renderer.AddActor2D(sbar)
+    return sbar
+
+# ---------- Small helpers ----------
+def poly_count(mesh: pv.PolyData) -> int:
+    if hasattr(mesh, "n_faces_strict"):
+        return mesh.n_faces_strict
+    return mesh.n_cells
+
+def md_to_html(txt: str) -> str:
+    if not txt:
+        return ""
+    safe = _html.escape(txt)
+    safe = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", safe)
+    return "<br/>".join(safe.splitlines())
+
+def bc_text_right(dataset: str) -> str:
+    if dataset == "Incompressible flow over car":
+        return (
+            "<b>Reference Density:</b> 1.225 kg/m³<br><br>"
+            "<b>Reference Viscosity:</b> 1.789e-5 Pa·s<br><br>"
+            "<b>Operating Pressure:</b> 101325 Pa"
+        )
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Ambient Temperature:</b> 218 K<br><br>"
+            "<b>Cruising velocity:</b> 250.0 m/s or 560 mph"
+        )
+    return ""
+
+def bc_text_left(dataset: str) -> str:
+    if dataset == "Compressible flow over plane":
+        return (
+            "<b>Reference Density:</b> 0.36 kg/m³<br><br>"
+            "<b>Reference viscosity:</b> 1.716e-05 kg/(m·s)<br><br>"
+            "<b>Operating Pressure:</b> 23842 Pa"
+        )
+    return ""
+
+# =====================================================================
+# =======================  APP  =======================================
+# =====================================================================
+class PFMDemo(TrameApp):
+    def __init__(self, server=None):
+        super().__init__(server)
+
+        # ---------------- VTK RENDERERS ----------------
+        self.ren_geom = vtkRenderer()
+        self.ren_geom.SetBackground(0.10, 0.16, 0.22)
+        self.rw_geom = vtkRenderWindow()
+        self.rw_geom.SetOffScreenRendering(1)
+        self.rw_geom.AddRenderer(self.ren_geom)
+        self.rwi_geom = vtkRenderWindowInteractor()
+        self.rwi_geom.SetRenderWindow(self.rw_geom)
+        self.rwi_geom.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_geom.Initialize()
+            self.rwi_geom.Enable()
+        except Exception:
+            pass
+
+        self.ren_pred = vtkRenderer()
+        self.ren_pred.SetBackground(0.10, 0.16, 0.22)
+        self.rw_pred = vtkRenderWindow()
+        self.rw_pred.SetOffScreenRendering(1)
+        self.rw_pred.AddRenderer(self.ren_pred)
+        self.rwi_pred = vtkRenderWindowInteractor()
+        self.rwi_pred.SetRenderWindow(self.rw_pred)
+        self.rwi_pred.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        try:
+            self.rwi_pred.Initialize()
+            self.rwi_pred.Enable()
+        except Exception:
+            pass
+
+        self.scalar_bar = None
+
+        # timers / flags
+        self._predict_t0 = None
+        self._infer_thread = None
+        self._pre_upload_thread = None
+        self._infer_heartbeat_on = False
+        self._loop = None
+
+        # ---------------- TRAME STATE ----------------
+        s = self.state
+        s.theme_dark = True
+
+        s.analysis_types = ANALYSIS_TYPE
+        s.analysis_type = DEFAULT_ANALYSIS_TYPE
+        s.dataset_choices = ANALYSIS_TYPE_MAPPING[DEFAULT_ANALYSIS_TYPE]
+        s.dataset = DEFAULT_DATASET
+        s.variable_choices = variables_for(DEFAULT_DATASET)
+        s.variable = s.variable_choices[0] if s.variable_choices else None
+
+        # dialog (still kept)
+        s.show_decimation_dialog = False
+        s.decim_override_enabled = False
+        s.decim_override_mode = "medium"
+        s.decim_override_custom = 0.5
+
+        # menu decimation defaults
+        s.decim_enable = False        # user MUST toggle to override auto
+        s.decim_target = 0.5
+        s.decim_min_faces = 5000         # <= important: 0 so small meshes can be reduced
+        s.decim_max_faces = int(1e7)
+
+        # register controller properly
+        # self.server.controller.decimate_again = self.decimate_again
+        # self.server.controller.add("decimate_again", self.decimate_again)
+        ctrl = self.server.controller
+
+        # ✅ this actually registers the trigger
+        ctrl.add("decimate_again", self.decimate_again)
+        ctrl.add("reset_mesh", self.reset_mesh)
+
+
+
+        s.show_velocity = (DEFAULT_DATASET == "Incompressible flow over car")
+        s.is_plane = (DEFAULT_DATASET == "Compressible flow over plane")
+        s.velocity_mph = 45.0
+
+        s.bc_text = get_boundary_conditions_text(DEFAULT_DATASET)
+        s.bc_left = bc_text_left(DEFAULT_DATASET)
+        s.bc_right = bc_text_right(DEFAULT_DATASET)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+        s.stats_html = "👋 Upload a geometry, then click Predict."
+        s.upload = None
+
+        # upload
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.pm_elapsed_upload = 0.0
+        s.upload_msg = ""
+
+        # predict
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.predict_elapsed = 0.0
+        s.predict_est_total = 0.0
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+
+        self._build_ui()
+
+    def _ensure_loop(self):
+        if self._loop is not None:
+            return self._loop
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        self._loop = loop
+        return loop
+
+    def _run_coro(self, coro):
+        loop = self._ensure_loop()
+        if loop.is_running():
+            return asyncio.ensure_future(coro, loop=loop)
+        return loop.run_until_complete(coro)
+
+    async def _flush_async(self):
+        try:
+            self.server.state.flush()
+        except Exception:
+            pass
+        await asyncio.sleep(0)
+
+    def _build_ui(self):
+        ctrl = self.server.controller
+        with SinglePageLayout(self.server, full_height=True) as layout:
+            layout.title.set_text("")    # clear
+            layout.title.hide = True     # hide default
+            with layout.toolbar:
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"      # overall width
+                        "margin: 0 auto;"         # center it
+                        "padding: 0 8px;"        # ← left/right margin
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSpacer()
+                    html.Div(
+                        "Ansys: Physics Foundation Model",
+                        style=(
+                            "width:100%;"
+                            "text-align:center;"
+                            "font-size:34px;"
+                            "font-weight:900;"
+                            "letter-spacing:0.4px;"
+                            "line-height:1.2;"
+                        ),
+                    )
+                    v3.VSpacer()
+
+            # toolbar
+            with layout.toolbar:
+                # ← same margin container for the second toolbar row
+                with v3.VContainer(
+                    fluid=True,
+                    style=(
+                        "max-width: 1800px;"
+                        "margin: 0 auto;"
+                        "padding: 0 8px;"
+                        "box-sizing: border-box;"
+                    ),
+                ):
+                    v3.VSwitch(
+                        v_model=("theme_dark",),
+                        label="Dark Theme",
+                        inset=True,
+                        density="compact",
+                        hide_details=True,
+                    )
+                    v3.VSpacer()
+
+            with layout.content:
+                html.Style("""
+                /* Small side padding for the whole app */
+                .v-application__wrap {
+                    padding-left: 8px;
+                    padding-right: 8px;
+                    padding-bottom: 8px;
+                }
+
+                :root {
+                    --pfm-font-ui: 'Inter', 'IBM Plex Sans', 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+                    --pfm-font-mono: 'JetBrains Mono', 'IBM Plex Mono', monospace;
+                }
+
+                html, body, .v-application {
+                    margin: 0;
+                    padding: 0;
+                    font-family: var(--pfm-font-ui) !important;
+                    font-weight: 500;
+                    letter-spacing: .25px;
+                    -webkit-font-smoothing: antialiased;
+                    -moz-osx-font-smoothing: grayscale;
+                    text-rendering: optimizeLegibility;
+                    line-height: 1.5;
+                    font-size: 15.5px;
+                    color: #ECEFF4;
+                }
+
+                /* ... keep all your other typography / button / slider styles here ... */
+
+                .v-theme--dark { background-color: #14171C !important; color: #ECEFF4 !important; }
+                .v-theme--light { background-color: #F6F7FA !important; color: #1F1F1F !important; }
+
+                /* (rest of your .pfm-* classes unchanged) */
+                """)
+
+                # html.Style("""
+                # .v-theme--dark { background: #1F232B !important; }
+                # .v-theme--light { background: #f5f6f8 !important; }
+                # .v-theme--dark .pfm-card { background: #23272F !important; color: #fff !important; }
+                # .v-theme--light .pfm-card { background: #ffffff !important; color: #1f232b !important; }
+                # .v-theme--dark .pfm-viewer { background: #15171d !important; }
+                # .v-theme--light .pfm-viewer { background: #e9edf3 !important; }
+                # .pfm-card { border-radius: 16px !important; box-shadow: 0 6px 24px rgba(0,0,0,0.12); }
+                # .pfm-progress .v-progress-linear { height: 22px !important; border-radius: 999px !important; }
+                # .pfm-btn-big.v-btn {
+                #     height: 48px !important;
+                #     font-size: 18px !important;
+                #     font-weight: 600 !important;
+                #     letter-spacing: 1.2px;
+                #     text-transform: none !important;
+                #     border-radius: 999px !important;
+                # }
+                # .pfm-viewer { min-height: 420px; height: 650px !important; border-radius: 16px; }
+                # """)
+                html.Link(
+                    rel="stylesheet",
+                    href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;600&display=swap",
+                )
+
+                with v3.VThemeProvider(theme=("theme_dark ? 'dark' : 'light'",)):
+                    with v3.VContainer(
+                        fluid=True,
+                        class_="pa-6",
+                        style=(
+                            "max-width: 2200px;"                     # max width of content
+                            "margin: 8px auto 16px auto;"          # top / left-right / bottom
+                            "padding: 0 8px;"                      # inner left/right padding
+                            "box-sizing: border-box;"
+                            "background: rgba(255,255,255,0.02);"
+                            "border-radius: 16px;"
+                        ),
+                    ):
+
+
+                        # 1) Physics Application
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧪 <b>Physics Application</b>",
+                                style="font-size:28px;font-weight:700;letter-spacing:1.1px;margin-bottom:10px;",
+                            )
+                            html.Div(
+                                "Select the type of analysis",
+                                style="font-size:24px;opacity:.82;margin-bottom:18px;",
+                            )
+                            toggle = v3.VBtnToggle(
+                                v_model=("analysis_type", self.state.analysis_type),
+                                class_="mt-1",
+                                mandatory=True,
+                                rounded=True,
+                            )
+                            # with toggle:
+                            #     for at in ANALYSIS_TYPE:
+                            #         v3.VBtn(
+                            #             at,
+                            #             value=at,
+                            #             variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                            #             class_="mr-2 pfm-toggle-xxl",
+                            #         )
+
+                            with toggle:
+                                for at in ANALYSIS_TYPE:
+                                    v3.VBtn(
+                                        at,
+                                        value=at,
+                                        variant=(f"analysis_type===`{at}` ? 'elevated' : 'tonal'"),
+                                        class_="mr-2 pfm-toggle-xxl",
+                                        style=(
+                                            "font-size:18px;"
+                                            "font-weight:800;"
+                                            "letter-spacing:0.4px;"
+                                            "text-transform:none;"
+                                        ),
+                                    )
+
+                        # 2) Dataset + Variable
+                        with v3.VRow(dense=True, class_="mb-3"):
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "🧩 Sub Application",
+                                        style="font-weight:700;font-size:24px;margin-bottom:14px;",
+                                    )
+                                    v3.VSelect(
+                                        v_model=("dataset", self.state.dataset),
+                                        items=("dataset_choices", self.state.dataset_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        style=(
+                                            "font-size:24px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        class_="pfm-big-select-subapp",
+                                        menu_props={"content_class": "pfm-subapp-list"},  # <— key for dropdown items
+                                    )
+                                    # v3.VSelect(
+                                    #     v_model=("dataset", self.state.dataset),
+                                    #     items=("dataset_choices", self.state.dataset_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     class_="pfm-big-select-subapp pfm-subapp-list",
+                                    #     style="font-size:21px;",
+                                    # )
+                            with v3.VCol(cols=6):
+                                with v3.VSheet(class_="pa-6 pfm-card", rounded=True, elevation=3):
+                                    html.Div(
+                                        "📊 Variable to Predict",
+                                        style="font-weight:700;font-size:20px;margin-bottom:14px;",
+                                    )
+
+                                    v3.VSelect(
+                                        v_model=("variable", self.state.variable),
+                                        items=("variable_choices", self.state.variable_choices),
+                                        hide_details=True,
+                                        density="comfortable",
+                                        class_="pfm-var-select",
+                                        style=(
+                                            "font-size:20px;"
+                                            "font-weight:800;"
+                                            "height:56px;"
+                                            "display:flex;"
+                                            "align-items:center;"
+                                        ),
+                                        menu_props={"content_class": "pfm-var-list"},
+                                    )
+                                                                        # v3.VSelect(
+                                    #     v_model=("variable", self.state.variable),
+                                    #     items=("variable_choices", self.state.variable_choices),
+                                    #     hide_details=True,
+                                    #     density="comfortable",
+                                    #     style="font-size:16px;",
+                                    # )
+
+                        # 3) Boundary Conditions
+                        with v3.VSheet(class_="pa-6 mb-4 pfm-card", rounded=True, elevation=3):
+                            html.Div(
+                                "🧱 Boundary Conditions",
+                                style="font-weight:700;font-size:22px;margin-bottom:16px;",
+                            )
+
+                            # two columns: Left = velocity controls, Right = reference text
+                            with v3.VRow(class_="align-start", dense=True):
+                                # ---- LEFT: velocity slider / readout ----
+                                with v3.VCol(cols=7, class_="pfm-vel"):
+                                    html.Div(
+                                        "🚗 Velocity (mph)",
+                                        class_="pfm-vel-title",
+                                        style="margin-bottom:8px;font-weight:800;font-size:21px;letter-spacing:.3px;",
+                                    )
+                                    html.Div(
+                                        "Set the inlet velocity in miles per hour",
+                                        class_="pfm-vel-sub",
+                                        style="margin-bottom:10px;font-size:20px;opacity:.95;",
+                                    )
+                                    v3.VSlider(
+                                        v_model=("velocity_mph", self.state.velocity_mph),
+                                        min=30.0, max=80.0, step=0.1,
+                                        thumb_label=True,
+                                        v_if=("show_velocity",),
+                                        style="height:54px;margin-top:12px;max-width:540px;",
+                                        class_="mt-3 mb-3 pfm-vel-slider",
+                                    )
+                                    html.Div(
+                                        "{{ velocity_mph.toFixed(0) }} / 80 "
+                                        "<span style='opacity:.95'>"
+                                        "({{ (velocity_mph * 0.44704).toFixed(2) }} m/s)</span>",
+                                        v_if=("show_velocity",),
+                                        class_="pfm-vel-readout",
+                                        style="font-size:18px;font-weight:900;letter-spacing:.3px;margin-top:6px;",
+                                    )
+
+                                # ---- RIGHT: fixed reference values (HTML from bc_text_right / bc_text_left) ----
+                                with v3.VCol(cols=5, class_="pfm-bc-right"):
+                                    html.Div(
+                                        v_html=("bc_text_html", ""),
+                                        style=(
+                                            "margin-top:6px;"
+                                            "font-size:18px;"
+                                            "line-height:1.7;"
+                                            "min-width:260px;"
+                                            "max-width:360px;"
+                                            "text-align:left;"
+                                        ),
+                                    )
+
+                        
+
+                        # 4) Two viewers
+                        with v3.VRow(style="margin-top: 24px;"):
+                            # LEFT = upload
+                            with v3.VCol(cols=6):
+                                with v3.VRow(class_="align-center justify-space-between mb-2"):
+                                    html.Div(
+                                        "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📤 Input Geometry</span>",
+                                    )
+
+                                    # ✅ working gear menu
+                                    with v3.VMenu(
+                                        location="bottom end",
+                                        close_on_content_click=False,
+                                        offset="4 8",
+                                    ):
+                                        # activator slot MUST expose { props } and we MUST bind them to the button
+                                        with v3.Template(v_slot_activator="{ props }"):
+                                            with v3.VBtn(
+                                                icon=True,
+                                                variant="text",
+                                                density="comfortable",
+                                                style="min-width:32px;",
+                                                v_bind="props",               # 👈 this is the key
+                                            ):
+                                                v3.VIcon("mdi-cog", size="22")
+
+                                        # menu content
+                                        with v3.VCard(class_="pa-4", style="min-width: 280px;"):
+                                            html.Div("<b>Mesh decimation</b>", class_="mb-3", style="font-size:14px;")
+
+                                            v3.VSwitch(
+                                                v_model=("decim_enable",),
+                                                label="Enable decimation",
+                                                inset=True,
+                                                hide_details=True,
+                                                class_="mb-4",
+                                            )
+
+                                            html.Div(
+                                                "Target reduction (fraction of faces to remove)",
+                                                class_="mb-1",
+                                                style="font-size:12px;color:#9ca3af;",
+                                            )
+                                            v3.VSlider(
+                                                v_model=("decim_target",),
+                                                min=0.0,
+                                                max=0.999,
+                                                step=0.001,
+                                                hide_details=True,
+                                                class_="mb-2",
+                                            )
+                                            html.Div("{{ decim_target.toFixed(3) }}", style="font-size:11px;", class_="mb-3")
+
+                                            with v3.VRow(dense=True, class_="mb-3"):
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Min faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_min_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+                                                with v3.VCol(cols=6):
+                                                    html.Div("Max faces", style="font-size:11px;color:#9ca3af;", class_="mb-1")
+                                                    v3.VTextField(
+                                                        v_model=("decim_max_faces",),
+                                                        type="number",
+                                                        density="compact",
+                                                        hide_details=True,
+                                                    )
+
+                                            v3.VBtn(
+                                                "Apply to current mesh",
+                                                block=True,
+                                                color="primary",
+                                                class_="mt-2",
+                                                click=self.decimate_again,
+                                            )
+
+                                            v3.VBtn(
+                                                "Reset to original mesh",
+                                                block=True,
+                                                variant="tonal",
+                                                class_="mt-2",
+                                                click=self.reset_mesh,       # 👈 will call the controller you added
+                                            )
+
+
+                                v3.VFileInput(
+                                    label="Select 3D File",
+                                    style="font-size:17px;padding:12px;height:50px;margin-bottom:20px;",
+                                    multiple=False,
+                                    show_size=True,
+                                    accept=".stl,.vtk,.vtp,.ply,.obj,.vtu,.glb",
+                                    v_model=("upload", None),
+                                    clearable=True,
+                                )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_geom = VtkRemoteView(
+                                        self.rw_geom,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                            rounded=True, elevation=3):
+                                    html.Div("<b>Upload</b>", style="font-size:18px;")
+
+                                    # progress bar: only while uploading
+                                    v3.VProgressLinear(
+                                        v_model=("pm_upload", 0),
+                                        height=22,
+                                        style="margin-top:10px;margin-bottom:10px;",
+                                        color="primary",
+                                        rounded=True,
+                                        v_show=("is_uploading",),   # 👈 bar disappears after upload
+                                    )
+
+                                    # text: percentage + time + message, only while uploading
+                                    html.Div(
+                                        "{{ pm_upload }}% — {{ pm_elapsed_upload.toFixed(2) }}s — {{ upload_msg }}",
+                                        style="font-size:14px;",
+                                        v_show=("is_uploading",),   # 👈 hide text after completion
+                                    )
+
+                                v3.VBtn(
+                                    "🗑️ CLEAR",
+                                    block=True,
+                                    variant="tonal",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.clear,
+                                )
+                            # RIGHT = prediction
+                            with v3.VCol(cols=6):
+                                html.Div(
+                                    "<span style='font-size:26px;font-weight:700;letter-spacing:1.1px;'>📈 Prediction Results</span>",
+                                    style="margin-bottom:10px;",
+                                )
+                                html.Div(
+                                    v_html=("stats_html",),
+                                    class_="mb-3",
+                                    style="font-size:20px;line-height:1.4;",
+                                )
+                                # v3.VProgressLinear(
+                                #     v_model=("predict_progress", 0),
+                                #     height=22,
+                                #     style="margin-top:6px;margin-bottom:12px;",
+                                #     color="primary",
+                                #     rounded=True,
+                                #     indeterminate=("predict_progress < 10",),
+                                #     v_show=("is_predicting",),
+                                # )
+                                # html.Div(
+                                #     "Predicting: {{ predict_progress }}%",
+                                #     style="font-size:14px;margin-bottom:10px;",
+                                #     v_show=("is_predicting",),
+                                # )
+                                with v3.VSheet(height=620, rounded=True, class_="pa-0 pfm-viewer"):
+                                    self.view_pred = VtkRemoteView(
+                                        self.rw_pred,
+                                        interactive=True,
+                                        interactive_ratio=1,
+                                        server=self.server,
+                                    )
+                                with v3.VSheet(class_="mt-3 pa-4 pfm-card pfm-progress",
+                                            rounded=True, elevation=3):
+                                    html.Div("<b>Inference</b>", style="font-size:18px;")
+
+                                    # 🔴 OLD: v_model=("predict_progress", 0), indeterminate=...
+                                    # 🟢 NEW: use pm_infer and a normal (non-indeterminate) bar
+                                    v3.VProgressLinear(
+                                        v_model=("pm_infer", 0),
+                                        height=22,
+                                        style="margin-top:6px;margin-bottom:12px;",
+                                        color="success",
+                                        rounded=True,
+                                        indeterminate=("predict_progress <= 0",),
+                                        v_show=("is_predicting",),   # 👈 bar only visible while predicting
+                                    )
+
+                                    # text line: % + elapsed time + current stage message
+                                    html.Div(
+                                        "{{ pm_infer }}% — {{ pm_elapsed_infer.toFixed(2) }}s — {{ predict_msg }}",
+                                        style="font-size:14px;margin-bottom:10px;",
+                                        # ❗ if you want the *text* to also disappear at the end, keep v_show;
+                                        # if you want the final "✅ Prediction complete — 1.23s" to stay, REMOVE v_show
+                                        v_show=("is_predicting",),
+                                    )
+                                v3.VBtn(
+                                    "🚀 PREDICT",
+                                    block=True,
+                                    color="primary",
+                                    class_="mt-3 pfm-btn-big",
+                                    style="--v-btn-height:38px;--v-btn-size:1.35rem;padding:0 32px;",
+                                    click=self.predict,
+                                )
+
+            layout.on_ready = self._first_paint
+
+    def _first_paint(self, **_):
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+    # ---------------------------------------------------------
+    # UPLOAD (async)
+    # ---------------------------------------------------------
+    def _write_upload_to_disk(self, payload) -> str:
+        if payload is None:
+            raise ValueError("No file payload")
+        if isinstance(payload, (list, tuple)):
+            payload = payload[0]
+        if isinstance(payload, str):
+            return payload
+        if not isinstance(payload, dict):
+            raise ValueError(f"Unsupported payload: {type(payload)}")
+        if payload.get("path"):
+            return payload["path"]
+        name = payload.get("name") or "upload"
+        content = payload.get("content")
+        if isinstance(content, str) and content.startswith("data:"):
+            content = content.split(",", 1)[1]
+        raw = base64.b64decode(content) if isinstance(content, str) else bytes(content)
+        os.makedirs(GEOM_DIR, exist_ok=True)
+        file_path = os.path.join(GEOM_DIR, name)
+        with open(file_path, "wb") as f:
+            f.write(raw)
+        return file_path
+
+    def _pre_upload_spinner_loop(self):
+        s = self.state
+        phase = 1
+        while self._pre_upload_on and not self._upload_actual_started and s.is_uploading:
+            s.pm_upload = max(1, min(9, phase))
+            s.upload_msg = "Initializing upload..."
+            try:
+                self.server.state.flush()
+            except Exception:
+                pass
+            phase = 1 if phase >= 9 else phase + 1
+            time.sleep(0.15)
+
+    def _start_pre_upload_spinner(self):
+        if self._pre_upload_thread and self._pre_upload_thread.is_alive():
+            return
+        self._upload_actual_started = False
+        self._pre_upload_on = True
+        self._pre_upload_thread = threading.Thread(
+            target=self._pre_upload_spinner_loop, daemon=True
+        )
+        self._pre_upload_thread.start()
+
+    def _stop_pre_upload_spinner(self):
+        self._pre_upload_on = False
+        self._pre_upload_thread = None
+
+    async def _fake_upload_bump(self, stop_event: asyncio.Event):
+        s = self.state
+        while not stop_event.is_set() and s.pm_upload < 9:
+            s.pm_upload += 1
+            await self._flush_async()
+            await asyncio.sleep(0.05)
+
+    async def _upload_worker_async(self, upload):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        s.is_uploading = True
+        s.upload_msg = "Starting upload..."
+        s.pm_elapsed_upload = 0.0
+
+        s.pm_upload = 5
+        self.server.state.flush()
+        await asyncio.sleep(0)
+
+        fake_stop = asyncio.Event()
+        fake_task = asyncio.create_task(self._fake_upload_bump(fake_stop))
+
+        try:
+            self._upload_actual_started = True
+            self._stop_pre_upload_spinner()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+                try:
+                    await fake_task
+                except asyncio.CancelledError:
+                    pass
+
+            s.upload_msg = "Writing file to disk..."
+            s.pm_upload = 10
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            file_path = await loop.run_in_executor(None, self._write_upload_to_disk, upload)
+
+            s.upload_msg = "Reading mesh..."
+            s.pm_upload = 20
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+            mesh = await loop.run_in_executor(None, pv.read, file_path)
+
+            # 3) decimation (auto first)
+            try:
+                nf = poly_count(mesh)
+            except Exception:
+                nf = mesh.n_cells
+
+            auto_tr = float(auto_target_reduction(nf))
+
+            # reflect auto in UI
+            s.decim_target = auto_tr
+            s.decim_min_faces = 5000            # <= allow decimation even for 27k faces
+            s.decim_max_faces = int(1e7)
+
+            target = auto_tr
+            min_faces = 5000
+            max_faces = int(1e7)
+
+            # user override
+            if self.state.decim_enable:
+                target = float(self.state.decim_target or 0.0)
+                min_faces = int(self.state.decim_min_faces or 5000)
+                max_faces = int(self.state.decim_max_faces or 1e7)
+
+            if target > 0.0:
+                s.upload_msg = f"Decimating mesh ({target:.3f})..."
+                s.pm_upload = max(s.pm_upload, 45)
+                s.pm_elapsed_upload = time.time() - t0
+                await self._flush_async()
+
+                dec_cfg = {
+                    "enabled": True,
+                    "method": "pro",
+                    "target_reduction": target,
+                    "min_faces": min_faces,
+                    "max_faces": max_faces,
+                }
+                mesh = await loop.run_in_executor(None, decimate_mesh, mesh, dec_cfg)
+
+            # 4) normals + save
+            s.upload_msg = "Preparing geometry..."
+            s.pm_upload = 75
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            def _normals_and_save(m):
+                m_fixed = m.compute_normals(
+                    consistent_normals=True,
+                    auto_orient_normals=True,
+                    point_normals=True,
+                    cell_normals=False,
+                    inplace=False,
+                )
+                geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+                m_fixed.save(geom_path_)
+                return geom_path_, m_fixed
+
+            geom_path, mesh_fixed = await loop.run_in_executor(None, _normals_and_save, mesh)
+
+            # 5) update viewer
+            self.ren_geom.RemoveAllViewProps()
+            self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+            self.ren_geom.ResetCamera()
+            try:
+                self.rw_geom.Render()
+            except Exception:
+                pass
+            self.view_geom.update()
+            # GEOMETRY_CACHE.current_mesh = mesh_fixed
+            GEOMETRY_CACHE.original_mesh = mesh_fixed.copy(deep=True)
+            GEOMETRY_CACHE.current_mesh = mesh_fixed
+
+            s.upload_msg = "✅ Geometry ready."
+            s.pm_upload = 100
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+        except Exception as e:
+            s.upload_msg = f"❌ Upload failed: {e}"
+            s.pm_upload = 0
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+        finally:
+            s.is_uploading = False
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            if not fake_stop.is_set():
+                fake_stop.set()
+            if not fake_task.done():
+                fake_task.cancel()
+                try:
+                    await fake_task
+                except Exception:
+                    pass
+
+    @change("upload")
+    def _on_upload_change(self, upload, **_):
+        if not upload:
+            return
+        self._run_coro(self._upload_worker_async(upload))
+
+    def decimate_again(self):
+        self._run_coro(self._decimate_again_async())
+
+    async def _decimate_again_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            # nothing to decimate
+            s.upload_msg = "No mesh to re-decimate"
+            await self._flush_async()
+            return
+
+        # --- start "upload-like" progress for manual decimation ---
+        t0 = time.time()
+        s.is_uploading = True
+        s.pm_upload = 5
+        s.pm_elapsed_upload = 0.0
+        s.upload_msg = "Starting mesh re-decimation..."
+        await self._flush_async()
+
+        try:
+            # read parameters from UI
+            try:
+                target = float(s.decim_target)
+            except Exception:
+                target = 0.0
+
+            try:
+                min_faces = int(s.decim_min_faces)
+            except Exception:
+                min_faces = 5000
+
+            try:
+                max_faces = int(s.decim_max_faces)
+            except Exception:
+                max_faces = int(1e7)
+
+            if (not s.decim_enable) or target <= 0.0:
+                s.upload_msg = "Decimation disabled"
+                s.pm_upload = 0
+                s.pm_elapsed_upload = time.time() - t0
+                await self._flush_async()
+                return
+
+            # --- bump before heavy decimation call ---
+            s.upload_msg = f"Re-decimating mesh ({target:.3f})..."
+            s.pm_upload = 25
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            dec_cfg = {
+                "enabled": True,
+                "method": "pro",
+                "target_reduction": target,
+                "min_faces": min_faces,
+                "max_faces": max_faces,
+            }
+
+            # heavy work on executor
+            mesh = await loop.run_in_executor(
+                None, decimate_mesh, GEOMETRY_CACHE.current_mesh, dec_cfg
+            )
+
+            # --- normals + save ---
+            s.upload_msg = "Recomputing normals & saving..."
+            s.pm_upload = 70
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            def _normals_and_save(m):
+                m_fixed = m.compute_normals(
+                    consistent_normals=True,
+                    auto_orient_normals=True,
+                    point_normals=True,
+                    cell_normals=False,
+                    inplace=False,
+                )
+                geom_path_ = os.path.join(GEOM_DIR, "geometry.stl")
+                m_fixed.save(geom_path_)
+                return geom_path_, m_fixed
+
+            geom_path, mesh_fixed = await loop.run_in_executor(
+                None, _normals_and_save, mesh
+            )
+
+            # --- update viewer ---
+            s.upload_msg = "Updating viewer..."
+            s.pm_upload = 90
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+            self.ren_geom.RemoveAllViewProps()
+            self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+            self.ren_geom.ResetCamera()
+            try:
+                self.rw_geom.Render()
+            except Exception:
+                pass
+            self.view_geom.update()
+
+            GEOMETRY_CACHE.current_mesh = mesh_fixed
+
+            # --- final bump ---
+            s.upload_msg = "✅ Re-decimated"
+            s.pm_upload = 100
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+
+        except Exception as e:
+            s.upload_msg = f"❌ Re-decimation failed: {e}"
+            s.pm_upload = 0
+            s.pm_elapsed_upload = time.time() - t0
+            await self._flush_async()
+        finally:
+            # hide bar + text after we’re done
+            s.is_uploading = False
+            await self._flush_async()
+
+
+    def reset_mesh(self):
+        self._run_coro(self._reset_mesh_async())
+
+    async def _reset_mesh_async(self):
+        s = self.state
+
+        if GEOMETRY_CACHE.original_mesh is None:
+            s.upload_msg = "No original mesh to reset to"
+            await self._flush_async()
+            return
+
+        # use the saved original
+        orig = GEOMETRY_CACHE.original_mesh
+
+        # save it again as current
+        GEOMETRY_CACHE.current_mesh = orig
+
+        # write to disk (so the STL on disk matches the viewer)
+        geom_path = os.path.join(GEOM_DIR, "geometry.stl")
+        orig.save(geom_path)
+
+        # update viewer
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_geom.AddActor(make_actor_from_stl(geom_path))
+        self.ren_geom.ResetCamera()
+        try:
+            self.rw_geom.Render()
+        except Exception:
+            pass
+        self.view_geom.update()
+
+        s.upload_msg = "↩️ Reset to original mesh"
+        await self._flush_async()
+
+    # ---------------------------------------------------------
+    # prediction
+    # ---------------------------------------------------------
+    def _start_infer_heartbeat(self):
+        if self._infer_thread and self._infer_thread.is_alive():
+            return
+
+        def loop_fn():
+            while self._infer_heartbeat_on:
+                if self.state.is_predicting and self._predict_t0 is not None:
+                    self.state.pm_elapsed_infer = max(0.0, time.time() - self._predict_t0)
+                    try:
+                        self.server.state.flush()
+                    except Exception:
+                        pass
+                time.sleep(0.12)
+
+        self._infer_heartbeat_on = True
+        self._infer_thread = threading.Thread(target=loop_fn, daemon=True)
+        self._infer_thread.start()
+
+    def _stop_infer_heartbeat(self):
+        self._infer_heartbeat_on = False
+        self._infer_thread = None
+
+    async def _predict_worker_async(self):
+        s = self.state
+        loop = self._ensure_loop()
+        t0 = time.time()
+
+        if GEOMETRY_CACHE.current_mesh is None:
+            s.predict_msg = "❌ Please upload geometry first"
+            s.is_predicting = False
+            await self._flush_async()
+            return
+
+        s.is_predicting = True
+        s.predict_progress = 1
+        s.pm_infer = 1
+        s.predict_msg = "Preparing inference..."
+        self._predict_t0 = time.time()
+        self._start_infer_heartbeat()
+        await self._flush_async()
+
+        try:
+            dataset = s.dataset
+            variable = s.variable
+            boundary = (
+                {"freestream_velocity": mph_to_ms(s.velocity_mph)}
+                if dataset == "Incompressible flow over car"
+                else None
+            )
+
+            s.predict_msg = "Loading model/checkpoint..."
+            s.predict_progress = 5
+            s.pm_infer = 5
+            await self._flush_async()
+
+            cfg, model, device, _ = await loop.run_in_executor(
+                None, MODEL_STORE.get, dataset, variable, None
+            )
+
+            s.predict_msg = "Processing mesh for inference..."
+            s.predict_progress = 35
+            s.pm_infer = 35
+            await self._flush_async()
+
+            def _run_full():
+                return run_inference_fast(
+                    dataset,
+                    variable,
+                    boundary_conditions=boundary,
+                    progress_cb=None,
+                )
+            viz = await loop.run_in_executor(None, _run_full)
+
+            s.predict_msg = "Preparing visualization..."
+            s.predict_progress = 85
+            s.pm_infer = 85
+            await self._flush_async()
+
+            stl_path = os.path.join(GEOM_DIR, "geometry.stl")
+            vmin = float(np.min(viz["pred"]))
+            vmax = float(np.max(viz["pred"]))
+
+            if os.path.exists(stl_path):
+                _tmp_trimesh, vmin, vmax = create_visualization_stl(viz, stl_path)
+                lut = build_jet_lut(vmin, vmax)
+                colored_actor = color_actor_with_scalars_from_prediction(
+                    stl_path,
+                    viz["points"],
+                    viz["pred"],
+                    variable,
+                    vmin,
+                    vmax,
+                    lut=lut,
+                )
+                self.ren_pred.AddActor(colored_actor)
+
+                units = {
+                    "pressure": "Pa",
+                    "x_velocity": "m/s",
+                    "y_velocity": "m/s",
+                    "z_velocity": "m/s",
+                }.get(variable, "")
+                title = f"{variable} ({units})" if units else variable
+                self.scalar_bar = add_or_update_scalar_bar(
+                    self.ren_pred, lut, title, label_fmt="%-0.2f", n_labels=8
+                )
+
+                src_cam = self.ren_geom.GetActiveCamera()
+                dst_cam = self.ren_pred.GetActiveCamera()
+                if src_cam is not None and dst_cam is not None:
+                    dst_cam.SetPosition(src_cam.GetPosition())
+                    dst_cam.SetFocalPoint(src_cam.GetFocalPoint())
+                    dst_cam.SetViewUp(src_cam.GetViewUp())
+                    dst_cam.SetParallelScale(src_cam.GetParallelScale())
+                    cr = src_cam.GetClippingRange()
+                    dst_cam.SetClippingRange(cr)
+
+                try:
+                    self.rw_pred.Render()
+                except Exception:
+                    pass
+                self.view_pred.update()
+
+            raw_vmin = float(np.min(viz["pred"]))
+            raw_vmax = float(np.max(viz["pred"]))
+
+            s.stats_html = (
+                f"<b>{variable} min:</b>{raw_vmin:.3e} "
+                f"<b>max:</b> {raw_vmax:.3e} "
+                f"<b>Confidence:</b> {viz['confidence_score']:.4f}"
+            )
+
+            s.predict_msg = "✅ Prediction complete."
+            s.predict_progress = 100
+            s.pm_infer = 100
+            s.predict_elapsed = time.time() - t0
+            s.pm_elapsed_infer = s.predict_elapsed
+            await self._flush_async()
+
+        except Exception as e:
+            s.predict_msg = f"❌ Prediction failed: {e}"
+            s.predict_progress = 0
+            s.pm_infer = 0
+            await self._flush_async()
+        finally:
+            s.is_predicting = False
+            self._stop_infer_heartbeat()
+            await self._flush_async()
+
+    @time_function("Inference and Visualization")
+    def predict(self, *_):
+        self._run_coro(self._predict_worker_async())
+
+    # ---------------------------------------------------------
+    # dataset wiring
+    # ---------------------------------------------------------
+    @change("analysis_type")
+    def _on_analysis_type_change(self, analysis_type=None, **_):
+        ds_list = ANALYSIS_TYPE_MAPPING.get(analysis_type or "", [])
+        default_ds = ds_list[0] if ds_list else None
+        self.state.dataset_choices = ds_list
+        if default_ds and self.state.dataset != default_ds:
+            self.state.dataset = default_ds
+        elif self.state.dataset:
+            self._apply_dataset(self.state.dataset)
+
+    @change("dataset")
+    def _on_dataset_change(self, dataset=None, **_):
+        if not dataset:
+            return
+        self._apply_dataset(dataset)
+
+    def _apply_dataset(self, ds: str):
+        s = self.state
+        opts = variables_for(ds) if ds else []
+        s.variable_choices = opts
+        s.variable = opts[0] if opts else None
+
+        s.show_velocity = (ds == "Incompressible flow over car")
+        s.is_plane = (ds == "Compressible flow over plane")
+
+        s.bc_text = get_boundary_conditions_text(ds)
+        s.bc_left = bc_text_left(ds)
+        s.bc_right = bc_text_right(ds)
+        s.bc_text_html = s.bc_right or md_to_html(s.bc_text)
+
+    # ---------------------------------------------------------
+    # clear
+    # ---------------------------------------------------------
+    def clear(self, *_):
+        for d in [GEOM_DIR, SOLN_DIR]:
+            if os.path.exists(d):
+                shutil.rmtree(d)
+            os.makedirs(d, exist_ok=True)
+        s = self.state
+        s.stats_html = "🧹 Cleared. Upload again."
+        s.is_uploading = False
+        s.pm_upload = 0
+        s.upload_msg = ""
+        s.pm_elapsed_upload = 0.0
+        s.is_predicting = False
+        s.predict_progress = 0
+        s.predict_msg = ""
+        s.pm_infer = 0
+        s.pm_elapsed_infer = 0.0
+        self.ren_geom.RemoveAllViewProps()
+        self.ren_pred.RemoveAllViewProps()
+        for rw, view in ((self.rw_geom, self.view_geom), (self.rw_pred, self.view_pred)):
+            try:
+                rw.Render()
+            except Exception:
+                pass
+            view.update()
+
+# ---------- main ----------
+def main():
+    app = PFMDemo()
+    app.server.controller.add("decimate_again", app.decimate_again)
+    app.server.controller.add("reset_mesh", app.reset_mesh)
+    app.server.start(7872)
+
+if __name__ == "__main__":
+    main()

configs/DrivAerML/config.yaml

@@ -0,0 +1,40 @@
+#data
+dataset_name: DrivAerML
+data_dir: /raid/ansysai/ajoglekar/Data/drivaerml_processed_data_surface
+splits_file: datasets/DrivAerML/train_val_test_splits.json
+# num_points: 40000
+num_points: 16384
+num_workers: 1
+presampled_exists: True
+# presampled_data_path: ../Data/drivaerml_processed_data_surface/presampled_val_test_data_40k  # Directory will be created if presampled_exists is False
+presampled_data_path:  /raid/ansysai/ajoglekar/Data/drivaerml_processed_data_surface/presampled_val_test_data_16k  # Directory will be created if presampled_exists is False
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 500
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: True
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+test_name: "ptautocastwithloss_test_priyesh"
+project_name: "DrivAerML"

configs/DriveAerNet/config.yaml

@@ -0,0 +1,57 @@
+#data
+dataset_name: DriveAerNet
+test_name: "baseline_exel_test"
+gpu_id: 0
+
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/1_Incompressible_external_flow/driveaer/1_VTK_surface
+splits_file: datasets/${dataset_name}/train_val_test_splits_400
+data_folder: driveaer
+
+normalization: "std_norm"
+physical_scale_for_test: True
+press_mean: -93.194176 
+press_std: 111.9078
+input_pos_mins: [-1.14437997, -1.02134001, 0.0]
+input_pos_maxs: [4.08646011, 1.02122998, 1.75308001]
+
+# num_points: 40000
+num_points: 10005
+num_workers: 1
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 1500
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: True
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: True
+
+
+project_name: ${dataset_name}

configs/app_configs/Compressible flow over plane/config.yaml

@@ -0,0 +1,58 @@
+#data
+dataset_name: plane_transonic
+test_name: "baseline"
+gpu_id: 0
+epochs: 300
+data_dir: Data/${dataset_name}/1_VTK_surface/
+
+json_file: ${data_dir}/params.json
+
+splits_file: ${data_dir}/
+data_folder: ${dataset_name}
+input_normalization: none
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+diff_input_velocity: false
+
+# num_points: 40000
+num_points: 30000 # 30000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: False
+
+
+project_name: ${dataset_name}

configs/app_configs/Compressible flow over plane/full_transform_params.json

@@ -0,0 +1,37 @@
+{
+  "mesh_stats": {
+    "min": [
+      7.045689443e-06,
+      -41.00179814,
+      -3.982239961
+    ],
+    "max": [
+      77.2491069,
+      41.00179814,
+      17.56380467
+    ],
+    "mean": [
+      25.50086541120836,
+      2.7514762491576034e-14,
+      1.3779085606454433
+    ],
+    "std": [
+      14.20950999685366,
+      8.283627425964518,
+      2.0614220403323915
+    ]
+  },
+  "scalars": {
+    "pressure": {
+      "min": -18114.4549,
+      "max": 16682.95124,
+      "mean": -1659.761628946487,
+      "std": 3701.8950182476274
+    }
+  },
+  "boundary_conditions_max": {
+    "fluid_density": 1.184,
+    "inlet_velocity": 30.0,
+    "viscosity_dynamic": 1.847e-05
+  }
+}

configs/app_configs/Compressible flow over plane/pca_embedding.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e59a7f72be4b38f18c86e643a8b859558eb6c6afca0801cadc265eb4a0fbd992
+size 824

configs/app_configs/Compressible flow over plane/pca_reducer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b511c4d5368bc70e0e79a090183eb12a17c5c806cb30c2b4bac33f20ad038c6
+size 30720772

configs/app_configs/Compressible flow over plane/pca_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa67ca7a567c3ba2799c46168878e91a1e70e2ba8a17e71eed70edb550c09ff6
+size 61440498

configs/app_configs/Compressible flow over plane/train_dist.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f34f5e7107b3cc05c1e5691c7cb78021f7d78b17ab9f8d10474743f9713c128d
+size 126618

configs/app_configs/Incompressible flow inside artery/config.yaml

@@ -0,0 +1,39 @@
+dataset_name: artery
+test_name: baseline_w_sincos_v1
+gpu_id: 0
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/0_Incompressible_internal_flow/artery/1_VTK_surface
+json_file: ${data_dir}/../full_transform_params.json
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+diff_input_velocity: false
+
+# num_points: 40000
+num_points: 10000 #15600
+num_workers: 1
+indim: 3
+outdim: 4
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 300
+optimizer:
+  type: AdamW
+scheduler: OneCycleLR
+loss_type: huber
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: true
+eval: false
+chunked_eval: true
+train_ckpt_load: false
+pos_embed_sincos: true
+project_name: ${dataset_name}

configs/app_configs/Incompressible flow inside artery/full_transform_params.json

@@ -0,0 +1,50 @@
+{
+  "mesh_stats": {
+    "min": [
+      0.025,
+      -1.204112099,
+      -1.222944777
+    ],
+    "max": [
+      9.975,
+      1.199037878,
+      1.197492383
+    ],
+    "mean": [
+      5.000000000023512,
+      -0.0050070103447356455,
+      0.0028514114550009695
+    ],
+    "std": [
+      2.8867160058379673,
+      0.2890868787382987,
+      0.29065190404236046
+    ]
+  },
+  "scalars": {
+    "pressure": {
+      "min": -4.88198,
+      "max": 23.20724818437452,
+      "mean": 3.2158044839488764,
+      "std": 3.9818469542284554
+    },
+    "x_velocity": {
+      "min": -1.070354126,
+      "max": 5.2829312809790085,
+      "mean": 1.0341798972778575,
+      "std": 0.8492951431118362
+    },
+    "y_velocity": {
+      "min": -1.0771796258219577,
+      "max": 1.0766134297782608,
+      "mean": -0.00017382796364451712,
+      "std": 0.2074833123027587
+    },
+    "z_velocity": {
+      "min": -1.109028642942948,
+      "max": 1.1098764213186418,
+      "mean": 0.0005453850642336799,
+      "std": 0.2126440513763686
+    }
+  }
+}

configs/app_configs/Incompressible flow inside artery/train_dist.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5bfb9b4197f81455710966c8e5bd8352368542b2193a5b50708ede030914725
+size 126618

configs/app_configs/Incompressible flow over car/config.yaml

@@ -0,0 +1,59 @@
+#data
+dataset_name: cadillac
+test_name: "baseline-variable-velocity-long"
+gpu_id: 0
+epochs: 1000
+data_dir: Data/${dataset_name}/1_VTK_surface/
+
+json_file: ${data_dir}/params.json
+
+splits_file: ${data_dir}/
+data_folder: ${dataset_name}
+input_normalization: shift_axis
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+
+diff_input_velocity: True # If true, inlet_x_velocity is added as an input feature
+
+# num_points: 40000
+num_points: 30000 #30000 #30000
+num_workers: 1
+
+#model
+indim: 4
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: False
+
+
+project_name: ${dataset_name}

configs/app_configs/Incompressible flow over car/full_transform_params.json

@@ -0,0 +1,40 @@
+{
+  "mesh_stats": {
+    "min": [
+      -3.4729325771331787,
+      -1.36235511302948,
+      -0.09825284779071808
+    ],
+    "max": [
+      3.9517974853515625,
+      1.36235511302948,
+      2.7738349437713623
+    ],
+    "mean": [
+      0.04156165739940759,
+      -1.009201088640187e-18,
+      0.7471213421336442
+    ],
+    "std": [
+      1.4202602139692266,
+      0.637785422763593,
+      0.4729766176454715
+    ]
+  },
+  "scalars": {
+    "pressure": {
+      "min": -2440.914306640625,
+      "max": 778.2598266601562,
+      "mean": -82.46476859198359,
+      "std": 145.29254059628536
+    }
+  },
+  "boundary_conditions_max": {
+    "fluid_density": 1.184,
+    "inlet_velocity": 35.0,
+    "viscosity_dynamic": 1.847e-05
+  },
+  "max_num_points": 925282,
+  "mean_num_points": 662953.6781609196,
+  "min_num_points": 469670
+}

configs/app_configs/Incompressible flow over car/pca_embedding.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a453f26faab0fb3be15e9fb484ab8dcdf35bde71257c264d83a5d6faf1642d2
+size 952

configs/app_configs/Incompressible flow over car/pca_reducer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19f552e22f7c2f73d1ee88142d3862c28778dea68929f03a28254b9c2fe5f4ac
+size 30720772

configs/app_configs/Incompressible flow over car/pca_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16de9f26dc9b6dcb9ce1175d3890b829c18504a88aafb1e63837c963d0375a89
+size 61440498

configs/app_configs/Incompressible flow over car/train_dist.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d16da556fd26a61f40756d78507b268681d137d667bf134da93985c010c95a98
+size 126618

configs/app_configs/Structural analysis of bracket/config.yaml

@@ -0,0 +1,58 @@
+#data
+dataset_name: deepjeb
+test_name: "baseline"
+gpu_id: 0
+epochs: 300
+data_dir:  /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/2_Structural_linear_static/deepjeb/1_VTK_surface/
+
+json_file: ${data_dir}/../full_transform_params.json
+
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "von_mises_stress"
+physical_scale_for_test: True
+
+
+# num_points: 40000
+num_points: 15000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 4
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: True
+
+
+project_name: ${dataset_name}

configs/app_configs/Structural analysis of bracket/full_transform_params.json

@@ -0,0 +1,61 @@
+{
+  "mesh_stats": {
+    "min": [
+      -39.4561,
+      -164.829,
+      -0.660644
+    ],
+    "max": [
+      73.00727,
+      21.59413,
+      65.88816
+    ],
+    "mean": [
+      14.378833339963359,
+      -70.12945824215386,
+      19.648179770356553
+    ],
+    "std": [
+      25.41684127064301,
+      49.219533224947526,
+      14.945247349739933
+    ]
+  },
+  "scalars": {
+    "von_mises_stress": {
+      "min": -379.1768394875346,
+      "max": 425.25385344927463,
+      "mean": 22.799127814174668,
+      "std": 77.70355231295902
+    },
+    "x_displacement": {
+      "min": -0.27920543884164056,
+      "max": 0.33591902881152996,
+      "mean": 0.028007646216518724,
+      "std": 0.059356218220308093
+    },
+    "y_displacement": {
+      "min": -0.10354705206573399,
+      "max": 0.10148109386521943,
+      "mean": -0.001005061685581641,
+      "std": 0.019455714218423757
+    },
+    "z_displacement": {
+      "min": -0.200961,
+      "max": 0.6233766340719438,
+      "mean": 0.08011871363216146,
+      "std": 0.10814779545698262
+    }
+  },
+  "boundary_conditions_max": {
+    "youngs_modulus": 113.8,
+    "poissons_ratio": 0.342,
+    "material_density": 0.00447,
+    "force_x": 0.0,
+    "force_y": 0.0,
+    "force_z": 35.6,
+    "torque_x": 0.0,
+    "torque_y": 0.0,
+    "torque_z": 0.0
+  }
+}

configs/app_configs/Structural analysis of bracket/train_dist.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f62cc7f80d090474c39fd0021e6b430d0e94117f31b37b3b7de4edfa1a8dc10b
+size 126618

configs/app_configs/Vehicle crash analysis/config.yaml

@@ -0,0 +1,58 @@
+#data
+dataset_name: deepjeb
+test_name: "baseline"
+gpu_id: 0
+epochs: 300
+data_dir:  /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/2_Structural_linear_static/deepjeb/1_VTK_surface/
+
+json_file: ${data_dir}/../full_transform_params.json
+
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "von_mises_stress"
+physical_scale_for_test: True
+
+
+# num_points: 40000
+num_points: 2000 #15000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 4
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: True
+
+
+project_name: ${dataset_name}

configs/app_configs/Vehicle crash analysis/full_transform_params.json

@@ -0,0 +1,61 @@
+{
+  "mesh_stats": {
+    "min": [
+      -39.4561,
+      -164.829,
+      -0.660644
+    ],
+    "max": [
+      73.00727,
+      21.59413,
+      65.88816
+    ],
+    "mean": [
+      14.378833339963359,
+      -70.12945824215386,
+      19.648179770356553
+    ],
+    "std": [
+      25.41684127064301,
+      49.219533224947526,
+      14.945247349739933
+    ]
+  },
+  "scalars": {
+    "von_mises_stress": {
+      "min": -379.1768394875346,
+      "max": 425.25385344927463,
+      "mean": 22.799127814174668,
+      "std": 77.70355231295902
+    },
+    "x_displacement": {
+      "min": -0.27920543884164056,
+      "max": 0.33591902881152996,
+      "mean": 0.028007646216518724,
+      "std": 0.059356218220308093
+    },
+    "y_displacement": {
+      "min": -0.10354705206573399,
+      "max": 0.10148109386521943,
+      "mean": -0.001005061685581641,
+      "std": 0.019455714218423757
+    },
+    "z_displacement": {
+      "min": -0.200961,
+      "max": 0.6233766340719438,
+      "mean": 0.08011871363216146,
+      "std": 0.10814779545698262
+    }
+  },
+  "boundary_conditions_max": {
+    "youngs_modulus": 113.8,
+    "poissons_ratio": 0.342,
+    "material_density": 0.00447,
+    "force_x": 0.0,
+    "force_y": 0.0,
+    "force_z": 35.6,
+    "torque_x": 0.0,
+    "torque_y": 0.0,
+    "torque_z": 0.0
+  }
+}

configs/app_configs/Vehicle crash analysis/train_dist.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f62cc7f80d090474c39fd0021e6b430d0e94117f31b37b3b7de4edfa1a8dc10b
+size 126618

configs/artery/config.yaml

@@ -0,0 +1,38 @@
+dataset_name: artery
+test_name: baseline_w_sincos_v1
+gpu_id: 0
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/0_Incompressible_internal_flow/artery/1_VTK_surface
+json_file: ${data_dir}/../full_transform_params.json
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+
+# num_points: 40000
+num_points: 2000 #15600
+num_workers: 1
+indim: 3
+outdim: 4
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 300
+optimizer:
+  type: AdamW
+scheduler: OneCycleLR
+loss_type: huber
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: true
+eval: false
+chunked_eval: true
+train_ckpt_load: false
+pos_embed_sincos: true
+project_name: ${dataset_name}

configs/artery/full_transform_params.json

@@ -0,0 +1,50 @@
+{
+  "mesh_stats": {
+    "min": [
+      0.025,
+      -1.204112099,
+      -1.222944777
+    ],
+    "max": [
+      9.975,
+      1.199037878,
+      1.197492383
+    ],
+    "mean": [
+      5.000000000023512,
+      -0.0050070103447356455,
+      0.0028514114550009695
+    ],
+    "std": [
+      2.8867160058379673,
+      0.2890868787382987,
+      0.29065190404236046
+    ]
+  },
+  "scalars": {
+    "pressure": {
+      "min": -4.88198,
+      "max": 23.20724818437452,
+      "mean": 3.2158044839488764,
+      "std": 3.9818469542284554
+    },
+    "x_velocity": {
+      "min": -1.070354126,
+      "max": 5.2829312809790085,
+      "mean": 1.0341798972778575,
+      "std": 0.8492951431118362
+    },
+    "y_velocity": {
+      "min": -1.0771796258219577,
+      "max": 1.0766134297782608,
+      "mean": -0.00017382796364451712,
+      "std": 0.2074833123027587
+    },
+    "z_velocity": {
+      "min": -1.109028642942948,
+      "max": 1.1098764213186418,
+      "mean": 0.0005453850642336799,
+      "std": 0.2126440513763686
+    }
+  }
+}

configs/cadillac/config.yaml

@@ -0,0 +1,60 @@
+#data
+dataset_name: cadillac 
+test_name: "baseline-variable-velocity-axis_v2_long_test"
+gpu_id: 1
+epochs: 1000
+# data_dir: /raid/ansysai/udbhav/alpha_Xdata/data_prep_transformer/${dataset_name}/1_VTK_surface/
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/data_prep_transformer/cadillac_v2/1_VTK_surface/
+
+
+json_file: ${data_dir}/params.json
+
+splits_file: ${data_dir}/
+data_folder: ${dataset_name}
+
+input_normalization: "shift_axis" # options: "min_max", "std_norm", "none"
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+
+diff_input_velocity: True # If true, inlet_x_velocity is added as an input feature
+
+# num_points: 40000
+num_points: 30000
+num_workers: 1
+
+#model
+indim: 4
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: True
+save_latent: True
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+pos_embed_sincos: False
+
+
+project_name: ${dataset_name}

configs/deepjeb/config.yaml

@@ -0,0 +1,58 @@
+#data
+dataset_name: deepjeb
+test_name: "baseline"
+gpu_id: 0
+epochs: 300
+data_dir:  /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/2_Structural_linear_static/deepjeb/1_VTK_surface/
+
+json_file: ${data_dir}/../full_transform_params.json
+
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "von_mises_stress"
+physical_scale_for_test: True
+
+
+# num_points: 40000
+num_points: 2000 #15000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 4
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: True
+
+
+project_name: ${dataset_name}

configs/deepjeb/full_transform_params.json

@@ -0,0 +1,61 @@
+{
+  "mesh_stats": {
+    "min": [
+      -39.4561,
+      -164.829,
+      -0.660644
+    ],
+    "max": [
+      73.00727,
+      21.59413,
+      65.88816
+    ],
+    "mean": [
+      14.378833339963359,
+      -70.12945824215386,
+      19.648179770356553
+    ],
+    "std": [
+      25.41684127064301,
+      49.219533224947526,
+      14.945247349739933
+    ]
+  },
+  "scalars": {
+    "von_mises_stress": {
+      "min": -379.1768394875346,
+      "max": 425.25385344927463,
+      "mean": 22.799127814174668,
+      "std": 77.70355231295902
+    },
+    "x_displacement": {
+      "min": -0.27920543884164056,
+      "max": 0.33591902881152996,
+      "mean": 0.028007646216518724,
+      "std": 0.059356218220308093
+    },
+    "y_displacement": {
+      "min": -0.10354705206573399,
+      "max": 0.10148109386521943,
+      "mean": -0.001005061685581641,
+      "std": 0.019455714218423757
+    },
+    "z_displacement": {
+      "min": -0.200961,
+      "max": 0.6233766340719438,
+      "mean": 0.08011871363216146,
+      "std": 0.10814779545698262
+    }
+  },
+  "boundary_conditions_max": {
+    "youngs_modulus": 113.8,
+    "poissons_ratio": 0.342,
+    "material_density": 0.00447,
+    "force_x": 0.0,
+    "force_y": 0.0,
+    "force_z": 35.6,
+    "torque_x": 0.0,
+    "torque_y": 0.0,
+    "torque_z": 0.0
+  }
+}

configs/driveaerpp/config.yaml

@@ -0,0 +1,56 @@
+#data
+dataset_name: driveaerpp
+test_name: "baseline_long_1500ep"
+gpu_id: 0
+epochs: 1500
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/1_Incompressible_external_flow/driveaernetpp/1_VTK_surface
+
+json_file: ${data_dir}/../full_transform_params.json
+
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: False
+
+num_points: 2000 #10000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: True
+
+
+project_name: ${dataset_name}

configs/driveaerpp/full_transform_params.json

@@ -0,0 +1,37 @@
+{
+  "mesh_stats": {
+    "min": [
+      -1.151419997215271,
+      -1.1943000555038452,
+      0.0
+    ],
+    "max": [
+      4.204110145568848,
+      1.1943000555038452,
+      1.76187002658844
+    ],
+    "mean": [
+      0.03162362053990364,
+      -0.004585757851600647,
+      0.009171515703201294
+    ],
+    "std": [
+      0.30713993310928345,
+      0.0957680270075798,
+      0.13543644547462463
+    ]
+  },
+  "scalars": {
+    "pressure": {
+      "min": -27552.19921875,
+      "max": 6858.10986328125,
+      "mean": -93.42745971679688,
+      "std": 120.5966567993164
+    }
+  },
+  "boundary_conditions_max": {
+    "fluid_density": 1.184,
+    "inlet_velocity": 30.0,
+    "viscosity_dynamic": 1.847e-05
+  }
+}

configs/elasticity/config.yaml

@@ -0,0 +1,32 @@
+#data
+data_dir: ../Data/elasticity
+dataset_name: elasticity
+ntrain: 1000
+ntest: 200
+
+#model
+indim: 2
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 128
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 1 
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 500
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR
+num_processes: 1
+max_grad_norm: 1.0
+eval: False
+
+
+#logging
+test_name: "OCLR_float32_A100_test"
+project_name: "elasticity"

configs/plane_engine_test/config.yaml

@@ -0,0 +1,57 @@
+#data
+dataset_name: plane_engine_test
+test_name: "sin_cos_4mn_long_wo_sincos_v3"
+gpu_id: 1
+epochs: 2500
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/xgm_data/data_prep_transformer/1_Incompressible_external_flow/plane/1_VTK_surface
+
+json_file: ${data_dir}/../full_transform_params.json
+
+splits_file: ${data_dir}/../
+data_folder: ${dataset_name}
+
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+
+# num_points: 40000
+num_points: 16035
+num_workers: 1
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: False
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: False
+
+
+project_name: ${dataset_name}

configs/plane_transonic/config.yaml

@@ -0,0 +1,62 @@
+#data
+dataset_name: plane_transonic
+test_name: "baseline_ep1000_v2_100_long_test"
+gpu_id: 0
+epochs: 300
+# data_dir: /raid/ansysai/udbhav/alpha_Xdata/data_prep_transformer/${dataset_name}/1_VTK_surface/
+data_dir: /raid/ansysai/udbhav/alpha_Xdata/data_prep_transformer/plane_transonic_v2/1_VTK_surface/
+
+
+json_file: ${data_dir}/params.json
+
+splits_file: ${data_dir}/
+data_folder: ${dataset_name}
+
+input_normalization: "none" # options: "min_max", "std_norm", "none"
+normalization: "std_norm"
+norm_vars: "pressure"
+physical_scale_for_test: True
+diff_input_velocity: false
+
+# num_points: 40000
+num_points: 30000
+num_workers: 1
+
+#model
+indim: 3
+outdim: 1
+model: ansysLPFMs
+hidden_dim: 256
+n_heads: 8
+n_decoder: 8
+mlp_ratio: 2
+
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR #OneCycleLR
+loss_type: huber  # options: mse, mae, huber
+
+# scheduler: LinearWarmupCosineAnnealingLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #currently default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models.
+eval: true
+save_latent: true
+
+
+chunked_eval: True # Default with True is evaluation of max chunks of size num_points that can fit in a data sample, to avoid small last chunks 
+train_ckpt_load: False ## Will load best model if ckpt_load is false
+
+#logging
+# test_name: "Final_surface_only_OCLR_3p9M_float32_A100"
+
+pos_embed_sincos: False
+
+
+project_name: ${dataset_name}

configs/shapenet_car_pv/config.yaml

@@ -0,0 +1,37 @@
+#data
+data_dir: /raid/ansysai/ajoglekar/Data/shapenet_car/mlcfd_data/training_data
+save_dir: /raid/ansysai/pkakka/6-Transformers/comparePhysicsLM/Data/shapenet_car/mlcfd_data/preprocessed_pv_data
+preprocessed: True
+dataset_name: shapenet_car_pv
+fold_id: 0
+num_workers: 1
+train_num_points_volume: 4096  #Training volume as well with shapenet?
+train_num_points_surface: 3586
+
+#model
+indim: 3
+outdim: 1
+vdim: 3
+sdim: 1
+model: ansysLPFMs
+hidden_dim: 256 ## Time series and decoder GPT?
+n_heads: 8
+n_decoder: 8 ## Any intution on how many decoders to use? heads etc? s
+mlp_ratio: 2
+
+#training
+val_iter: 1
+lr: 0.001
+batch_size: 1
+epochs: 1
+optimizer: 
+    type: AdamW
+scheduler: OneCycleLR
+num_processes: 1
+max_grad_norm: 1.0
+mixed_precision: True #if True, default fp16 is selected by torch.autocast(). Fp16 gave the best results for Transformer based models. Can change to bf16 with dtpye arguments if required.
+eval: False
+
+#logging
+test_name: "surface_only_float32_A100_test"
+project_name: "ShapeNetCar_PV"

dataset_loader.py

@@ -0,0 +1,188 @@
+
+import os
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader
+import pyvista as pv
+import json
+import glob
+
+class Data_loader(Dataset):
+    def __init__(self, cfg, split, epoch_seed=None, mode='train'):
+        """
+        data_dir: parent directory 
+        split: list of int, e.g. [0,1,2,3,4] for train, [5] for val, [6] for test
+        num_points: number of points to sample per geometry
+        epoch_seed: seed for random sampling (for training)
+        mode: 'train', 'val', or 'test'
+        """
+        self.data_dir = cfg.data_dir
+        self.split = split
+        self.num_points = cfg.num_points
+        self.epoch_seed = epoch_seed
+        self.mode = mode
+        self.cfg = cfg
+        self.meshes = []
+        self.mesh_names = []
+        for idx in split:
+            # Find folder matching *_{idx}
+            folder = os.path.join(self.data_dir, f"{idx}")
+            if not os.path.exists(folder):
+                raise FileNotFoundError(f"No folder matching '{idx}' found in {self.data_dir}")
+
+            # Find file matching *_{idx}.vtp inside the folder
+            vtp_files = glob.glob(os.path.join(folder, f"{idx}.vtp"))
+            if not vtp_files:
+                raise FileNotFoundError(f"No file matching '{idx}.vtp' found in {folder}")
+            vtp_file = vtp_files[0]
+            mesh = pv.read(vtp_file)
+            self.meshes.append(mesh)
+            self.mesh_names.append(os.path.splitext(os.path.basename(vtp_file))[0])
+        # For validation chunking
+        self.val_indices = None
+        self.val_chunk_ptr = 0
+        with open(cfg.json_file, "r") as f:
+            self.json_data = json.load(f)
+     
+    def set_epoch(self, epoch):
+        self.epoch_seed = epoch
+        self.val_indices = None
+        self.val_chunk_ptr = 0
+
+    def __len__(self):
+        if self.mode == 'train':
+            return len(self.meshes)
+        elif self.mode == 'val':
+            return len(self.meshes)
+        elif self.mode == 'test':
+            # Number of chunks = total points in all val meshes // num_points + remainder chunk
+            total = 0
+            for mesh in self.meshes:
+                return len(self.meshes)
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+
+    def __getitem__(self, idx):
+
+        if self.mode == 'train' or self.mode == 'val':
+            # Each item is a geometry, sample num_points randomly
+            mesh = self.meshes[idx]
+            n_pts = mesh.points.shape[0]
+            rng = np.random.default_rng(self.epoch_seed+idx)
+            indices = rng.choice(n_pts, self.num_points, replace=False)
+            pos = mesh.points
+            pos = torch.tensor(pos, dtype=torch.float32)
+            pressure = torch.tensor( mesh["pressure"][indices], dtype=torch.float32).unsqueeze(-1)
+            
+            if self.cfg.normalization == "std_norm":
+                target = (pressure - self.json_data["scalars"]["pressure"]["mean"]) / self.json_data["scalars"]["pressure"]["std"]
+
+            if self.cfg.diff_input_velocity:
+                inlet_x_vel = torch.tensor( mesh["inlet_x_velocity"], dtype=torch.float32).unsqueeze(-1)
+                pos = torch.cat((pos,inlet_x_vel),dim = 1)
+            
+            if self.cfg.input_normalization == "shift_axis":
+                coords = pos[:,:3].clone()
+
+                # Shift x: set minimum x (front bumper) to 0
+                coords[:, 0] = coords[:, 0] - coords[:, 0].min()
+
+                # Shift z: set minimum z (ground) to 0
+                coords[:, 2] = coords[:, 2] - coords[:, 2].min()
+
+                # Shift y: center about 0 (left/right symmetry)
+                y_center = (coords[:, 1].max() + coords[:, 1].min()) / 2.0
+                coords[:, 1] = coords[:, 1] - y_center
+
+                pos[:,:3] = coords
+                
+                
+            if self.cfg.pos_embed_sincos:
+                
+                if self.cfg.diff_input_velocity:
+                    raise Exception("pos_embed_sincos not supported with diff_input_velocity=True")
+                
+                input_pos_mins = torch.tensor(self.json_data["mesh_stats"]["min"])
+                input_pos_maxs = torch.tensor(self.json_data["mesh_stats"]["max"])
+                pos = 1000*(pos - input_pos_mins) / (input_pos_maxs - input_pos_mins)
+                assert torch.all(pos >= 0) 
+                assert torch.all(pos <= 1000)
+
+            pos = pos[indices]
+            
+            return {"input_pos": pos, "output_feat": target ,"data_id": self.mesh_names[idx]}
+
+        elif self.mode == 'test':
+            # For each mesh in test, scramble all points and return the full mesh
+            mesh = self.meshes[idx]
+            n_pts = mesh.points.shape[0]
+            rng = np.random.default_rng(self.epoch_seed+idx)
+            indices = rng.permutation(n_pts)
+            pos = mesh.points
+            
+            pos = torch.tensor(pos, dtype=torch.float32)
+            pressure = torch.tensor( mesh["pressure"][indices], dtype=torch.float32).unsqueeze(-1)
+
+            if self.cfg.normalization == "std_norm":
+                target = (pressure - self.json_data["scalars"]["pressure"]["mean"]) / self.json_data["scalars"]["pressure"]["std"]
+                
+            if hasattr(self.cfg, "diff_input_velocity") and self.cfg.diff_input_velocity:
+            
+                inlet_x_vel = torch.tensor( mesh["inlet_x_velocity"], dtype=torch.float32).unsqueeze(-1)
+                pos = torch.cat((pos,inlet_x_vel),dim = 1)
+                
+            if self.cfg.input_normalization == "shift_axis":
+                
+                coords = pos[:,:3].clone()
+
+                # Shift x: set minimum x (front bumper) to 0
+                coords[:, 0] = coords[:, 0] - coords[:, 0].min()
+
+                # Shift z: set minimum z (ground) to 0
+                coords[:, 2] = coords[:, 2] - coords[:, 2].min()
+
+                # Shift y: center about 0 (left/right symmetry)
+                y_center = (coords[:, 1].max() + coords[:, 1].min()) / 2.0
+                coords[:, 1] = coords[:, 1] - y_center
+
+                pos[:,:3] = coords
+             
+            if self.cfg.pos_embed_sincos:
+                
+                if hasattr(self.cfg, "diff_input_velocity") and self.cfg.diff_input_velocity:
+                    raise Exception("pos_embed_sincos not supported with diff_input_velocity=True")
+                
+                input_pos_mins = torch.tensor(self.json_data["mesh_stats"]["min"])
+                input_pos_maxs = torch.tensor(self.json_data["mesh_stats"]["max"])
+                pos = 1000*(pos - input_pos_mins) / (input_pos_maxs - input_pos_mins)
+                assert torch.all(pos >= 0) 
+                assert torch.all(pos <= 1000)
+            
+            pos = pos[indices]
+            
+            return {"input_pos": pos, "output_feat": target ,"data_id": self.mesh_names[idx],"physical_coordinates":mesh.points[indices]}
+
+        else:
+            raise ValueError(f"Unknown mode: {self.mode}")
+
+def get_dataloaders(cfg):
+   
+
+    with open(os.path.join(cfg.splits_file, "train.txt")) as f:
+        train_split = [line.strip() for line in f if line.strip()]
+    with open(os.path.join(cfg.splits_file, "test.txt")) as f:
+        val_split = [line.strip() for line in f if line.strip()]
+    with open(os.path.join(cfg.splits_file, "test.txt")) as f:
+        test_split = [line.strip() for line in f if line.strip()]
+    print("Indices in test_split:", test_split[:5])  # Print first 5 indices for verification
+
+
+    train_dataset = Data_loader(cfg, train_split, mode='train')
+    val_dataset = Data_loader(cfg, val_split, mode='val')
+    test_dataset = Data_loader(cfg, test_split, mode='test')
+
+    train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False)
+    test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
+
+    return train_loader, val_loader, test_loader

datasets/DrivAerML/README.md

@@ -0,0 +1,15 @@
+# Downloading dataset
+Run download_dataset.sh after setting LOCAL_DIR (path to where files should be downloaded) <br>
+Currently only stl files (drivaer_i.stl) and surface points and fields files (boundary_i.vtp) are being downloaded. <br>
+
+# Preprocess dataset
+Run preprocess_data.py after setting the paths of downloaded data (input_dir) and where processed data should be saved (output_dir) in data_preprocessing.yaml. This will create .npy files in output_dir. <br>
+Currently only surface quantities are being stored in the npy files. Change model_type in data_preprocessing.yaml to 'volume' or 'combined' for other quantities to be stored. <br>
+The dataset does not provide train/val/test splits. splits_creation.py can be used for creating and saving the splits in train_val_test_splits.json. <br>
+
+# Dataset and Dataloader
+dataset_drivaerml.py has the Dataset class. Use get_dataloaders function for the Dataloaders. <br>
+For first run use config argument 'presampled_exists': False. <br>
+Set 'num_points' argument in config file and those many points will be sampled from each sample and stored in path set in 'presampled_data_path' argument in config. <br>
+
+Refer to \url{https://huggingface.co/datasets/neashton/drivaerml} and \url{https://github.com/NVIDIA/physicsnemo/tree/main/examples/cfd/external_aerodynamics/domino} for further details.

datasets/DrivAerML/data_preprocessing.yaml

@@ -0,0 +1,20 @@
+#data
+dataset_name: DrivAerML
+data_processor: # Data processor configurable parameters
+  output_dir: ../../../Data/drivaerml_processed_data_surface # path to where processed data should be saved
+  input_dir: ../../../Data/drivaerml_data # path to where raw downloaded data is stored
+  num_processors: 12
+
+variables:
+  surface:
+    solution:
+      # The following is for AWS DrivAer dataset.
+      pMeanTrim: scalar
+      wallShearStressMeanTrim: vector
+  volume:
+    solution:
+      # The following is for AWS DrivAer dataset.
+      UMeanTrim: vector
+      pMeanTrim: scalar
+      nutMeanTrim: scalar
+model_type: surface

datasets/DrivAerML/dataset_drivaerml.py

@@ -0,0 +1,451 @@
+"""
+DrivAerML Dataset with Memory-Efficient Presampling Support
+
+This dataset implements presampling functionality for training, validation and test data.
+The presampling feature ensures consistent results across different runs, with memory-efficient 
+on-demand loading.
+
+Presampling Workflow:
+1. Set presampled=False in config to create presampled training, validation and test data
+2. The system creates fixed samples for all splits
+3. Each run's presampled data is saved as individual files in a directory structure
+4. Set presampled=True in config to use the saved presampled data for future runs
+
+Directory Structure:
+presampled_data_path/
+├── train/
+│   ├── run_1.npy
+│   ├── run_2.npy
+│   └── ...
+├── validation/
+│   ├── run_1.npy
+│   ├── run_2.npy
+│   └── ...
+└── test/
+    ├── run_1.npy
+    ├── run_2.npy
+    └── ...
+
+Configuration Parameters:
+- presampled: Boolean flag to control whether to use presampled data
+- presampled_data_path: Base path where presampled data directory is created
+
+Usage:
+- First run: Set presampled=False to create presampled data
+- Subsequent runs: Set presampled=True to use existing presampled data
+"""
+
+import os
+import numpy as np
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torch.utils.data import default_collate
+import json
+import re
+from sklearn.cluster import KMeans
+from sklearn.neighbors import NearestNeighbors
+
+def create_presampled_data(cfg, splits, save_path):
+    """
+    Create presampled training, validation and test data with fixed random sampling.
+    Saves individual files for each run to enable on-demand loading.
+    
+    Args:
+        cfg: Configuration object
+        splits: Dictionary containing train/validation/test splits
+        save_path: Base path for saving presampled data (directory will be created)
+    """
+    print("Creating presampled training, validation and test data...")
+    
+    # Create directory structure for presampled data
+    base_dir = os.path.splitext(save_path)[0]  # Remove .npy extension if present
+    os.makedirs(base_dir, exist_ok=True)
+    
+    # Set seed for reproducible sampling
+    np.random.seed(0)
+    
+    for split_type in ['train', 'validation', 'test']:
+        print(f"Processing {split_type} split...") 
+        split_runs = splits[split_type]
+        
+        # Create subdirectory for this split
+        split_dir = os.path.join(base_dir, split_type)
+        os.makedirs(split_dir, exist_ok=True)
+        
+        for run_number in split_runs:
+            # Find the corresponding .npy file
+            for f in os.listdir(cfg.data_dir):
+                if f.endswith('.npy'):
+                    match = re.search(r'run_(\d+)', f)   ## Very inefficient?
+                    if match and int(match.group(1)) == run_number:
+                        npy_file_path = os.path.join(cfg.data_dir, f)
+                        
+                        # Load the original data
+                        data = np.load(npy_file_path, allow_pickle=True).item()
+                        coordinates = data['surface_mesh_centers']
+                        field = data['surface_fields']
+                        
+                        # Sample points with fixed seed for reproducibility
+                        sample_indices = np.random.choice(coordinates.shape[0], cfg.num_points, replace=False)
+                        sampled_coordinates = coordinates[sample_indices, :]
+                        sampled_field = field[sample_indices, :]
+                        
+                        # Save individual presampled file for this run
+                        presampled_run_data = {
+                            'surface_mesh_centers': sampled_coordinates,
+                            'surface_fields': sampled_field
+                        }
+                        
+                        run_file_path = os.path.join(split_dir, f'run_{run_number}.npy')
+                        np.save(run_file_path, presampled_run_data)
+                        break
+    
+    print(f"Presampled data saved to directory: {base_dir}")
+    print(f"Structure: {base_dir}/{{train,validation,test}}/run_{{number}}.npy")
+    
+    return base_dir
+
+class DrivAerMLDataset(Dataset):
+    def __init__(self, cfg, splits = None, split_type = 'train', presampled = False, save_presampled_data_path = None):
+        """
+        Initializes the DrivAerMLDataset instance.
+
+        Args:
+            cfg: Configuration object containing data directory and number of points
+            splits: List of run numbers to include, if None includes all files
+            split_type: Type of split ('train', 'validation', 'test')
+            presampled: Whether to use presampled data
+            save_presampled_data_path: Base path to the presampled data directory
+        """
+        self.data_dir = cfg.data_dir
+        self.chunked_eval = cfg.chunked_eval
+        self.splits = splits
+        
+        # Store only run numbers and create filename mapping for efficiency
+        self.run_numbers = []
+        self.original_filenames = {}  # run_number -> original filename
+        
+        for f in os.listdir(cfg.data_dir):
+            if f.endswith('.npy'):
+                match = re.search(r'run_(\d+)', f)
+                if match:
+                    run_number = int(match.group(1))
+                    if run_number in splits:
+                        self.run_numbers.append(run_number)
+                        self.original_filenames[run_number] = f
+        
+        if len(self.run_numbers) == 0:
+            raise ValueError(f"No .npy files found in directory: {cfg.data_dir}")
+            
+        self.num_points = cfg.num_points
+        self.split_type = split_type
+        self.presampled = presampled  # Is there a script for non presampled dataloader?
+        
+        # Set up presampled data directory path (but don't load data yet)
+        if self.presampled and save_presampled_data_path:
+            self.presampled_base_dir = os.path.splitext(save_presampled_data_path)[0]
+            self.presampled_split_dir = os.path.join(self.presampled_base_dir, self.split_type)
+            if not os.path.exists(self.presampled_split_dir):
+                raise FileNotFoundError(f"Presampled data directory not found: {self.presampled_split_dir}")
+
+    def __len__(self):
+        return len(self.run_numbers)
+
+    def __getitem__(self, idx):
+        run_number = self.run_numbers[idx]
+        
+        if self.presampled:
+            # Load presampled data on-demand
+            presampled_file_path = os.path.join(self.presampled_split_dir, f'run_{run_number}.npy')
+            if os.path.exists(presampled_file_path):
+                data_dict = np.load(presampled_file_path, allow_pickle=True).item()
+                coordinates = data_dict['surface_mesh_centers']
+                field = data_dict['surface_fields'][:,0:1]
+            else:
+                raise FileNotFoundError(f"Presampled file not found: {presampled_file_path}")
+        else:
+            # Load original data
+            original_filename = self.original_filenames[run_number]
+            original_file_path = os.path.join(self.data_dir, original_filename)
+            data = np.load(original_file_path, allow_pickle=True).item()
+            coordinates = data['surface_mesh_centers']
+            field = data['surface_fields'][:,0:1]
+            
+            # Random sampling
+            sample_indices = np.random.choice(coordinates.shape[0], self.num_points, replace=False)
+            coordinates = coordinates[sample_indices,:]
+            field = field[sample_indices,0:1]
+
+        if self.split_type == 'test' and self.chunked_eval:
+            # Load original data
+            original_filename = self.original_filenames[run_number]
+            original_file_path = os.path.join(self.data_dir, original_filename)
+            data = np.load(original_file_path, allow_pickle=True).item()
+            coordinates = data['surface_mesh_centers']
+            field = data['surface_fields'][:,0:1]
+            num_chunks = coordinates.shape[0]//self.num_points
+            indices = torch.randperm(coordinates.shape[0])[:self.num_points*num_chunks]
+            # indices = torch.randperm(coordinates.shape[0])
+            coordinates = coordinates[indices,:]
+            field = field[indices,0:1]
+
+
+        coordinates_tensor = torch.tensor(coordinates, dtype=torch.float32)
+        field_tensor = torch.tensor(field, dtype=torch.float32)
+
+        # Use mean-std normalization for coordinates
+        coordinates_tensor = (coordinates_tensor - INPUT_POS_MEAN) / INPUT_POS_STD
+        field_tensor = (field_tensor - PRESSURE_MEAN) / PRESSURE_STD
+
+        data = {'input_pos': coordinates_tensor, 'output_feat': field_tensor, 'output_pos': coordinates_tensor}
+
+        return data
+
+
+def calculate_normalization_constants(dataloader):
+    """
+    Calculate normalization constants for both pressure values and coordinate ranges
+    across the entire training dataset.
+    
+    Args:
+        dataloader: Training DataLoader
+        
+    Returns:
+        tuple: (pressure_mean, pressure_std, coord_ranges, coord_mean, coord_std)
+               where coord_ranges = {'min_x', 'max_x', 'min_y', 'max_y', 'min_z', 'max_z'}
+               coord_mean = [mean_x, mean_y, mean_z]
+               coord_std = [std_x, std_y, std_z]
+    """
+    all_pressures = []
+    all_coordinates = []  # Store all coordinate points for mean/std calculation
+    
+    # Initialize coordinate extremes
+    max_x = float('-inf')
+    max_y = float('-inf')
+    max_z = float('-inf')
+    min_x = float('inf')
+    min_y = float('inf')
+    min_z = float('inf')
+    
+    print("Calculating normalization constants...")
+    for batch_idx, batch in enumerate(dataloader):
+        # Process pressure values
+        output_feat = batch['output_feat']
+        pressures = output_feat.flatten().numpy()
+        all_pressures.extend(pressures)
+        
+        # Process coordinate ranges and collect all coordinates
+        input_pos = batch['input_pos']
+        # Convert tensor to numpy for coordinate calculations
+        input_pos_np = input_pos.numpy()
+        
+        # Collect all coordinate points for mean/std calculation
+        # Reshape from (batch_size, num_points, 3) to (batch_size * num_points, 3)
+        coords_reshaped = input_pos_np.reshape(-1, 3)
+        all_coordinates.extend(coords_reshaped)
+        
+        # Calculate coordinate ranges
+        max_x = max(max_x, np.max(input_pos_np[:,:,0]))
+        max_y = max(max_y, np.max(input_pos_np[:,:,1]))
+        max_z = max(max_z, np.max(input_pos_np[:,:,2]))
+        min_x = min(min_x, np.min(input_pos_np[:,:,0]))
+        min_y = min(min_y, np.min(input_pos_np[:,:,1]))
+        min_z = min(min_z, np.min(input_pos_np[:,:,2]))
+        
+        if batch_idx % 10 == 0:  # Print progress every 10 batches
+            print(f"Processed {batch_idx + 1} batches...")
+    
+    # Convert to numpy arrays for efficient computation
+    all_pressures = np.array(all_pressures)
+    all_coordinates = np.array(all_coordinates)  # Shape: (total_points, 3)
+    
+    # Calculate pressure statistics
+    pressure_mean = np.mean(all_pressures)
+    pressure_std = np.std(all_pressures)
+    
+    # Calculate coordinate statistics (mean and std for each dimension)
+    coord_mean = np.mean(all_coordinates, axis=0)  # [mean_x, mean_y, mean_z]
+    coord_std = np.std(all_coordinates, axis=0)    # [std_x, std_y, std_z]
+    
+    # Store coordinate ranges
+    coord_ranges = {
+        'min_x': min_x, 'max_x': max_x,
+        'min_y': min_y, 'max_y': max_y,
+        'min_z': min_z, 'max_z': max_z
+    }
+    
+    # Print comprehensive statistics
+    print(f"\nPressure statistics from {len(all_pressures)} data points:")
+    print(f"Mean: {pressure_mean:.6f}")
+    print(f"Std:  {pressure_std:.6f}")
+    print(f"Min:  {np.min(all_pressures):.6f}")
+    print(f"Max:  {np.max(all_pressures):.6f}")
+    
+    print(f"\nCoordinate ranges:")
+    print(f"X: [{min_x:.6f}, {max_x:.6f}]")
+    print(f"Y: [{min_y:.6f}, {max_y:.6f}]")
+    print(f"Z: [{min_z:.6f}, {max_z:.6f}]")
+    
+    print(f"\nCoordinate statistics for mean-std normalization from {len(all_coordinates)} data points:")
+    print(f"Mean: [{coord_mean[0]:.6f}, {coord_mean[1]:.6f}, {coord_mean[2]:.6f}]")
+    print(f"Std:  [{coord_std[0]:.6f}, {coord_std[1]:.6f}, {coord_std[2]:.6f}]")
+    
+    print(f"\nFor use in dataset file:")
+    print(f"INPUT_POS_MEAN = torch.tensor([{coord_mean[0]:.6f}, {coord_mean[1]:.6f}, {coord_mean[2]:.6f}])")
+    print(f"INPUT_POS_STD = torch.tensor([{coord_std[0]:.6f}, {coord_std[1]:.6f}, {coord_std[2]:.6f}])")
+    
+    return pressure_mean, pressure_std, coord_ranges, coord_mean, coord_std
+
+
+def seed_worker(worker_id):
+    worker_seed = torch.initial_seed() % 2**32
+    np.random.seed(worker_seed)
+
+g = torch.Generator()
+g.manual_seed(0)
+
+def get_dataloaders(cfg):
+    splits = json.load(open(cfg.splits_file)) # How is train validation used in DrivAerML?
+    
+    # Handle presampling logic
+    presampled_data_path = getattr(cfg, 'presampled_data_path', os.path.join(cfg.data_dir, 'presampled_val_test_data.npy'))
+    presampled_base_dir = os.path.splitext(presampled_data_path)[0]
+    
+    if not cfg.presampled_exists:
+        # Create presampled data if it doesn't exist or if presampled=False
+        if not os.path.exists(presampled_base_dir):
+            print("=" * 60)
+            print("PRESAMPLING MODE: Creating presampled validation and test data...")
+            print(f"Presampled data will be saved to: {presampled_base_dir}")
+            create_presampled_data(cfg, splits, presampled_data_path)
+            print("Presampled data created successfully!")
+            print("You can now set presampled=True in config for future runs to use this presampled data.")
+            print("=" * 60)
+        else:
+            print(f"Presampled data directory already exists at: {presampled_base_dir}")
+            print("Using existing presampled data. Set presampled=True to use it in future runs.")
+    
+    if not cfg.presampled_exists :
+        print(f"Warning: presampled=True but presampled data directory not found at {presampled_base_dir}")
+        print("Creating presampled data...")
+        create_presampled_data(cfg, splits, presampled_data_path)
+
+    use_presampled = True
+    print(f"Using presampled training, validation and test data from: {presampled_base_dir}")
+
+    
+    train_dataset = DrivAerMLDataset(cfg, splits = splits['train'], split_type = 'train',
+                                     presampled = use_presampled, save_presampled_data_path = presampled_data_path)
+    val_dataset = DrivAerMLDataset(cfg, splits = splits['validation'], split_type = 'validation',
+                                   presampled = use_presampled, save_presampled_data_path = presampled_data_path)
+    test_dataset = DrivAerMLDataset(cfg, splits = splits['test'], split_type = 'test',
+                                    presampled = use_presampled, save_presampled_data_path = presampled_data_path)
+
+    collate_fn = None
+
+    train_dataloader = DataLoader(
+        train_dataset, batch_size=cfg.batch_size, shuffle=True,
+        drop_last=True, num_workers=cfg.num_workers, collate_fn=collate_fn, 
+        worker_init_fn=seed_worker, generator=g
+    )
+    val_dataloader = DataLoader(
+        val_dataset, batch_size=cfg.batch_size, shuffle=True,
+        drop_last=True, num_workers=cfg.num_workers, collate_fn=collate_fn,
+        worker_init_fn=seed_worker, generator=g
+    )
+    test_dataloader = DataLoader(
+        test_dataset, batch_size=1, shuffle=False,
+        drop_last=False, num_workers=cfg.num_workers, collate_fn=collate_fn,
+        worker_init_fn=seed_worker, generator=g
+    )
+
+    # # Calculate normalization constants
+    # print('Calculating normalization constants...')
+    # pressure_mean, pressure_std, coord_ranges, coord_mean, coord_std = calculate_normalization_constants(train_dataloader)
+    # exit()
+
+    return train_dataloader, val_dataloader, test_dataloader
+
+
+
+# Pressure statistics from openfoam surface train dataset (10k points sampled):
+# Mean: -229.845718
+# Std:  269.598572
+# Min:  -3651.057861
+# Max:  859.160034
+
+# Coordinate ranges:
+# X: [-0.941836, 4.131968]
+# Y: [-1.129535, 1.125530]
+# Z: [-0.317549, 1.244577]
+
+# Pressure statistics from full openfoam surface train dataset (3323811346 data points):
+# Mean: -229.266983
+# Std:  269.226807
+# Min:  -111492.804688
+# Max:  6382.190918
+
+# Coordinate ranges:
+# X: [-0.942579, 4.132785]
+# Y: [-1.131676, 1.131676]
+# Z: [-0.317577, 1.244584]
+
+# Coordinate statistics for mean-std normalization (computed from full dataset):
+# Mean: [1.595103, 0.000000, 0.463503]
+# Std:  [1.434788, 0.801948, 0.440890]
+
+
+
+# Pressure statistics from 6553600 data points:
+# Mean: -0.003021
+# Std:  1.002092
+# Min:  -14.342350
+# Max:  4.157114
+
+# Coordinate ranges:
+# X: [-1.768229, 1.766621]
+# Y: [-1.408318, 1.410171]
+# Z: [-1.771534, 1.781146]
+
+# Coordinate statistics for mean-std normalization from 6553600 data points:
+# Mean: [-0.076668, -0.001889, -0.831090]
+# Std:  [0.968414, 0.882944, 0.858088]
+
+# For use in dataset file:
+# INPUT_POS_MEAN = torch.tensor([-0.076668, -0.001889, -0.831090])
+# INPUT_POS_STD = torch.tensor([0.968414, 0.882944, 0.858088])
+
+# # With full dataset - pressure normalization
+# PRESSURE_MEAN = -229.266983
+# PRESSURE_STD = 269.226807
+
+# # Coordinate normalization using mean-std
+# INPUT_POS_MEAN = torch.tensor([1.595103, 0.000000, 0.463503])
+# INPUT_POS_STD = torch.tensor([1.434788, 0.801948, 0.440890])
+
+# # Legacy min-max normalization (keep for reference but not used)
+# input_pos_mins = torch.tensor([-0.942579, -1.131676, -0.317577])
+# input_pos_maxs = torch.tensor([4.132785, 1.131676, 1.244584])
+
+
+# With full dataset - pressure normalization
+PRESSURE_MEAN = -229.266983
+PRESSURE_STD = 269.226807
+
+# Coordinate normalization using mean-std
+INPUT_POS_MEAN = torch.tensor([1.490858, -0.001515, 0.099364])
+INPUT_POS_STD = torch.tensor([1.388309, 0.706769, 0.380478])
+
+# # Legacy min-max normalization (keep for reference but not used)
+# input_pos_mins = torch.tensor([-0.942579, -1.131676, -0.317577])
+# input_pos_maxs = torch.tensor([4.132785, 1.131676, 1.244584])
+
+
+# Pressure normalization
+# PRESSURE_MEAN = 0
+# PRESSURE_STD = 1
+
+# # Coordinate normalization using mean-std
+# INPUT_POS_MEAN = torch.tensor([0, 0, 0])
+# INPUT_POS_STD = torch.tensor([1, 1, 1])
+