paddle 1.1.4__tar.gz → 1.1.5__tar.gz

{paddle-1.1.4 → paddle-1.1.5}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.1.4
+current_version = 1.1.5
 commit = True
 tag = True
 

{paddle-1.1.4 → paddle-1.1.5}/.github/workflows/ci.yml

@@ -57,4 +57,4 @@ jobs:
 
       - name: Install Python dependencies
         run: |
-          pip install numpy pytest 'pyharp>=1.7.1' 'torch==2.7.1'
+          pip install numpy scipy pytest paddle

paddle-1.1.5/Makefile

@@ -0,0 +1,26 @@
+ENV_FILE := .env
+UID := $$(id -u)
+GID := $$(id -g)
+
+.PHONY: env up down build
+
+env:
+	@echo "USER=$$(id -un)" > $(ENV_FILE)
+	@echo "USER_UID=$$(id -u)" >> $(ENV_FILE)
+	@echo "USER_GID=$$(id -g)" >> $(ENV_FILE)
+	@echo "Wrote $(ENV_FILE):"; cat $(ENV_FILE)
+
+up: env
+	@docker compose up -d
+
+down:
+	@docker compose down
+
+ps:
+	@docker compose ps
+
+start:
+	@docker compose exec --user $(UID):$(GID) dev bash
+
+build: env
+	@docker compose up -d --build dev

{paddle-1.1.4 → paddle-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paddle
-Version: 1.1.4
+Version: 1.1.5
 Summary: Python Atmospheric Dynamics: Discovery and Learning about Exoplanets. An open-source, user-friendly python frontend of canoe
 Project-URL: Homepage, https://github.com/elijah-mullens/paddle
 Project-URL: Repository, https://github.com/elijah-mullens/paddle
@@ -22,8 +22,8 @@ Classifier: Topic :: Scientific/Engineering :: Astronomy
 Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.9
-Requires-Dist: kintera>=1.0.1
-Requires-Dist: snapy>=0.7.0
+Requires-Dist: kintera>=1.1.5
+Requires-Dist: snapy>=0.8.2
 Requires-Dist: torch<=2.7.1,>=2.7.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == 'dev'
@@ -31,3 +31,52 @@ Description-Content-Type: text/markdown
 
 # paddle
 Python Atmospheric Dynamics: Discovering and Learning about Exoplanets. An open-source, user-friendly python version of canoe.
+
+## Install docker and docker-compose plugin
+
+
+## Create a python virtual environment
+```bash
+python -m venv pyenv
+```
+
+# Create a docker container
+```bash
+make up
+```
+
+# Terminate a docker container
+```bash
+make down
+```
+
+# Start a docker container
+```bash
+make start
+```
+
+# Build a new docker image (rarely used)
+```bash
+make build
+```
+
+## For Development
+### Cache your github credential
+```bash
+git config credential.helper 'cache --timeout=86400'
+```
+
+### Install paddle package
+```bash
+pip install paddle
+```
+
+### Install pre-commit hook
+```bash
+pip install pre-commit
+```
+
+### Install pre-commit hook
+```bash
+pre-commit install
+```

paddle-1.1.5/README.md

@@ -0,0 +1,51 @@
+# paddle
+Python Atmospheric Dynamics: Discovering and Learning about Exoplanets. An open-source, user-friendly python version of canoe.
+
+## Install docker and docker-compose plugin
+
+
+## Create a python virtual environment
+```bash
+python -m venv pyenv
+```
+
+# Create a docker container
+```bash
+make up
+```
+
+# Terminate a docker container
+```bash
+make down
+```
+
+# Start a docker container
+```bash
+make start
+```
+
+# Build a new docker image (rarely used)
+```bash
+make build
+```
+
+## For Development
+### Cache your github credential
+```bash
+git config credential.helper 'cache --timeout=86400'
+```
+
+### Install paddle package
+```bash
+pip install paddle
+```
+
+### Install pre-commit hook
+```bash
+pip install pre-commit
+```
+
+### Install pre-commit hook
+```bash
+pre-commit install
+```

paddle-1.1.5/docker/.dockerignore

@@ -0,0 +1,8 @@
+.git
+__pycache__/
+*.pyc
+build/
+dist/
+.venv/
+.env
+data/

paddle-1.1.5/docker/Dockerfile

@@ -0,0 +1,131 @@
+# syntax=docker/dockerfile:1.7
+ARG CUDA_VER=12.9.1
+ARG UBUNTU_VER=22.04
+
+############################
+# Base CUDA toolchain
+############################
+FROM nvidia/cuda:${CUDA_VER}-devel-ubuntu${UBUNTU_VER} AS base
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    TZ=UTC
+
+# System deps (C++ toolchain, Python, venv, git, neovim, etc.)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      gosu tini \
+      build-essential \
+      gcc g++ gfortran \
+      ninja-build \
+      cmake \
+      git curl ca-certificates \
+      python3 python3-pip python3-venv python3-dev \
+      pkg-config \
+      libssl-dev \
+      ripgrep fd-find unzip neovim \
+      clangd \
+      nodejs npm \
+      && rm -rf /var/lib/apt/lists/*
+
+# Make fd available as `fd` (Ubuntu calls it fdfind)
+RUN update-alternatives --install /usr/bin/fd fd /usr/bin/fdfind 50
+
+# Default editor env
+ENV EDITOR=nvim VISUAL=nvim
+
+# System-wide git editor default (users can override)
+RUN git config --system core.editor "nvim"
+
+# Pre-warm plugins (optional, speeds first start)
+# This runs Neovim headless to install plugins via lazy.nvim.
+RUN nvim --headless "+Lazy! sync" +qa || true
+
+############################
+# Convenient command-line tools
+############################
+
+# ---- after base tooling is installed, before switching USER ----
+# Create a tools dir and put it on PATH
+RUN mkdir -p /opt/tools
+ENV PATH="/opt/tools:${PATH}"
+
+# Copy all helper scripts
+COPY docker/scripts/ /opt/tools/
+# Ensure executables
+RUN find /opt/tools -type f -name "*.sh" -exec chmod +x {} \; \
+    && for f in /opt/tools/*.sh; do ln -sf "$f" "/usr/local/bin/$(basename "${f%.sh}")"; done
+# The symlink makes command-line tools available (no .sh needed)
+
+############################
+# Configure non-root user and Python venv
+############################
+
+# Python venv in /opt/venv (global, fast, easy)
+RUN python3 -m venv /opt/venv
+ENV VIRTUAL_ENV=/opt/venv
+ENV PATH="/opt/venv/bin:${PATH}"
+
+# Upgrade pip/setuptools/wheel early
+RUN pip install --upgrade pip setuptools wheel build
+
+# Optional: pin pip resolver behavior and set default index/extra-index if needed
+# COPY docker/pip.conf /etc/pip.conf
+
+# Put a base Neovim config in /etc/skel so future users get it,
+# and also install for the existing dev user.
+#RUN mkdir -p /etc/skel/.config/nvim
+#COPY docker/nvim/ /etc/skel/.config/nvim/
+#RUN mkdir -p /home/${USERNAME}/.config/nvim && \
+#    cp -r /etc/skel/.config/nvim/* /home/${USERNAME}/.config/nvim/ && \
+#    chown -R ${USERNAME}:${USERNAME} /home/${USERNAME}/.config/nvim
+
+############################
+# Cache Python wheels separately (optional but recommended)
+############################
+FROM base AS wheels
+WORKDIR /tmp/wheels
+# If you use requirements.txt:
+COPY docker/requirements.txt .
+RUN --mount=type=cache,target=/root/.cache/pip \
+    pip wheel -r requirements.txt -w /tmp/wheelhouse
+
+# If you use Poetry/pyproject, replace the above with:
+# COPY pyproject.toml poetry.lock ./
+# RUN pip install "poetry>=1.8.0"
+# RUN --mount=type=cache,target=/root/.cache/pip poetry export -f requirements.txt --without-hashes | tee req.txt
+# RUN --mount=type=cache,target=/root/.cache/pip pip wheel -r req.txt -w /tmp/wheelhouse
+
+############################
+# Dev image
+############################
+FROM base AS dev
+WORKDIR /workspace
+
+# Load for login shells
+#RUN printf 'alias vi=nvim\nalias vim=nvim\nexport TERM=xterm-256color\n' >> /home/${USERNAME}/.bashrc
+
+# Bring in prebuilt wheels (fast installs)
+COPY --from=wheels /tmp/wheelhouse /tmp/wheelhouse
+COPY docker/requirements.txt /workspace/docker/requirements.txt
+
+# Install Python deps from wheels first, then fall back to index
+RUN --mount=type=cache,target=/root/.cache/pip \
+    pip install --no-index --find-links=/tmp/wheelhouse -r /workspace/docker/requirements.txt \
+ || pip install -r /workspace/docker/requirements.txt
+
+# (Optional) CUDA env defaults for many toolchains
+ENV TORCH_CUDA_ARCH_LIST="8.6;8.9;9.0+PTX"  \
+    CUDA_CACHE_MAXSIZE=2147483647
+
+# Put your entrypoint in place
+COPY docker/entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/entrypoint.sh
+
+# Keep the workspace owned by the non-root user
+#RUN chown -R ${USERNAME}:${USERNAME} /workspace
+#USER ${USERNAME}
+
+#ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+#CMD ["/bin/bash"]
+
+ENTRYPOINT ["/usr/bin/tini","--","/usr/local/bin/entrypoint.sh"]
+CMD ["/bin/bash"]

paddle-1.1.5/docker/entrypoint.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+: "${USER_UID:=1000}"
+: "${USER_GID:=1000}"
+: "${USERNAME:=cli}"
+
+# Activate venv for login shells and non-interactive shells
+export VIRTUAL_ENV=/opt/venv
+export PATH="$VIRTUAL_ENV/bin:$PATH"
+
+# If user mounts code to /workspace, ensure ownership doesn’t break builds
+
+# Create group if missing
+if ! getent group "${USER_GID}" >/dev/null 2>&1; then
+  groupadd -g "${USER_GID}" "${USERNAME}" || groupadd -g "${USER_GID}" "grp${USER_GID}" || true
+fi
+
+# Create user if missing
+if ! id -u "${USER_UID}" >/dev/null 2>&1; then
+  useradd -m -u "${USER_UID}" -g "${USER_GID}" -s /bin/bash "${USERNAME}" || true
+fi
+
+# Ensure home exists
+HOME_DIR="$(getent passwd "${USER_UID}" | cut -d: -f6)"
+mkdir -p "${HOME_DIR}"
+
+# Make sure our common writable paths are owned (skip bind mounts like /workspace)
+for d in /opt/venv; do
+  if [ -d "$d" ]; then chown -R "${USER_UID}:${USER_GID}" "$d" || true; fi
+done
+
+# Export editor defaults for the user
+echo 'export EDITOR=nvim; export VISUAL=nvim' >> "${HOME_DIR}/.bashrc" || true
+chown "${USER_UID}:${USER_GID}" "${HOME_DIR}/.bashrc" || true
+
+# Configure git
+if [ -f /host/.gitconfig ] && [ ! -e "${HOME_DIR}/.gitconfig" ]; then
+  ln -s /host/.gitconfig "${HOME_DIR}/.gitconfig"
+  chown -h "${USER_UID}:${USER_GID}" "${HOME_DIR}/.gitconfig" || true
+
+  #cp /host/.gitconfig "${HOME_DIR}/.gitconfig"
+  #chown "${USER_UID}:${USER_GID}" "${HOME_DIR}/.gitconfig"
+  #chmod 600 "${HOME_DIR}/.gitconfig"
+fi
+
+# Drop privileges (use tini/gosu if installed; otherwise su-exec/ runuser)
+if command -v gosu >/dev/null 2>&1; then
+  exec gosu "${USER_UID}:${USER_GID}" "$@"
+else
+  exec runuser -u "$(id -nu "${USER_UID}")" -- "$@"
+fi
+
+# Print helpful banner
+echo "Dev container ready. Python: $(python --version)"
+echo "CUDA version: $(nvcc --version | sed -n 's/^.*release \(.*\),.*/\1/p')"
+exec "$@"

paddle-1.1.5/docker/nvim/init.lua

@@ -0,0 +1,32 @@
+-- Basic settings
+vim.g.mapleader = " "
+vim.o.termguicolors = true
+vim.o.number = true
+vim.o.relativenumber = true
+vim.o.signcolumn = "yes"
+vim.o.updatetime = 300
+vim.o.clipboard = "unnamedplus"
+vim.o.expandtab = true
+vim.o.shiftwidth = 2
+vim.o.tabstop = 2
+
+-- Lazy.nvim bootstrap
+local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
+if not vim.loop.fs_stat(lazypath) then
+  vim.fn.system({
+    "git","clone","--filter=blob:none",
+    "https://github.com/folke/lazy.nvim.git",
+    "--branch=stable", lazypath
+  })
+end
+vim.opt.rtp:prepend(lazypath)
+
+require("lazy").setup(require("plugins"), {
+  ui = { border = "rounded" }
+})
+
+-- Keymaps (Telescope)
+vim.keymap.set("n", "<leader>ff", "<cmd>Telescope find_files<cr>")
+vim.keymap.set("n", "<leader>fg", "<cmd>Telescope live_grep<cr>")
+vim.keymap.set("n", "<leader>fb", "<cmd>Telescope buffers<cr>")
+vim.keymap.set("n", "<leader>fh", "<cmd>Telescope help_tags<cr>")

paddle-1.1.5/docker/nvim/lua/plugins.lua

@@ -0,0 +1,89 @@
+return {
+  -- Core UX
+  { "nvim-lua/plenary.nvim" },
+  { "nvim-telescope/telescope.nvim", cmd = "Telescope" },
+
+  -- Syntax & TS
+  {
+    "nvim-treesitter/nvim-treesitter",
+    build = ":TSUpdate",
+    config = function()
+      require("nvim-treesitter.configs").setup {
+        ensure_installed = { "lua", "vim", "python", "cpp", "cuda", "cmake", "markdown" },
+        highlight = { enable = true },
+        indent = { enable = true },
+      }
+    end
+  },
+
+  -- Statusline
+  {
+    "nvim-lualine/lualine.nvim",
+    config = function()
+      require("lualine").setup { options = { theme = "auto" } }
+    end
+  },
+
+  -- Git goodies
+  {
+    "lewis6991/gitsigns.nvim",
+    config = function() require("gitsigns").setup() end
+  },
+
+  -- LSP, Mason, completion
+  { "williamboman/mason.nvim",
+    config = function() require("mason").setup() end
+  },
+  { "williamboman/mason-lspconfig.nvim",
+    dependencies = { "neovim/nvim-lspconfig" },
+    config = function()
+      require("mason-lspconfig").setup {
+        ensure_installed = { "clangd", "pyright" }
+      }
+      local lspconfig = require("lspconfig")
+      lspconfig.clangd.setup {}
+      lspconfig.pyright.setup {}
+    end
+  },
+  {
+    "hrsh7th/nvim-cmp",
+    dependencies = {
+      "hrsh7th/cmp-nvim-lsp",
+      "hrsh7th/cmp-buffer",
+      "hrsh7th/cmp-path",
+      "L3MON4D3/LuaSnip",
+    },
+    config = function()
+      local cmp = require("cmp")
+      cmp.setup({
+        snippet = { expand = function(args) require("luasnip").lsp_expand(args.body) end },
+        mapping = cmp.mapping.preset.insert({
+          ["<C-Space>"] = cmp.mapping.complete(),
+          ["<CR>"]      = cmp.mapping.confirm({ select = true }),
+          ["<C-e>"]     = cmp.mapping.abort(),
+        }),
+        sources = cmp.config.sources({
+          { name = "nvim_lsp" }, { name = "path" }, { name = "buffer" }
+        }),
+      })
+      -- LSP capabilities for completion
+      local caps = require("cmp_nvim_lsp").default_capabilities()
+      require("lspconfig").clangd.setup { capabilities = caps }
+      require("lspconfig").pyright.setup { capabilities = caps }
+    end
+  },
+
+  -- Formatting/Linting (optional)
+  {
+    "nvimtools/none-ls.nvim",
+    config = function()
+      local null_ls = require("null-ls")
+      null_ls.setup({
+        sources = {
+          null_ls.builtins.formatting.clang_format,
+          null_ls.builtins.formatting.black,
+        },
+      })
+    end
+  },
+}

paddle-1.1.5/docker/scripts/git-done

@@ -0,0 +1,96 @@
+#!/bin/sh
+# sync-main-and-delete-current.sh
+# Usage: sync-main-and-delete-current.sh [-f] [-r] [-s]
+#   -f  force delete even if branch not merged (uses -D)
+#   -r  also delete remote branch on origin
+#   -s  stash uncommitted changes before switching branches
+
+set -eu
+
+FORCE=0
+DEL_REMOTE=0
+DO_STASH=0
+
+while getopts "frs" opt; do
+  case "$opt" in
+    f) FORCE=1 ;;
+    r) DEL_REMOTE=1 ;;
+    s) DO_STASH=1 ;;
+    *) echo "Usage: $0 [-f] [-r] [-s]"; exit 2 ;;
+  esac
+done
+
+# Ensure we're in a git repo
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  echo "Not inside a git repository." >&2
+  exit 1
+fi
+
+# Determine current branch (avoid empty on detached HEAD)
+CURRENT_BRANCH="$(git symbolic-ref --short -q HEAD || true)"
+if [ -z "${CURRENT_BRANCH}" ] || [ "${CURRENT_BRANCH}" = "HEAD" ]; then
+  echo "Detached HEAD; please checkout a branch first." >&2
+  exit 1
+fi
+
+if [ "${CURRENT_BRANCH}" = "main" ]; then
+  echo "Already on 'main'; nothing to delete." >&2
+  exit 1
+fi
+
+# Optionally stash changes to avoid switch failures
+if [ "${DO_STASH}" -eq 1 ]; then
+  # Only stash if there are changes
+  if ! git diff --quiet || ! git diff --cached --quiet; then
+    echo "Stashing local changes..."
+    git stash push -u -m "auto-stash by sync-main-and-delete-current"
+  fi
+fi
+
+echo "Fetching from origin..."
+git fetch origin
+
+# Ensure local main exists; create it tracking origin/main if needed
+if ! git show-ref --verify --quiet refs/heads/main; then
+  echo "Local 'main' missing; creating tracking branch..."
+  git branch --track main origin/main >/dev/null 2>&1 || true
+fi
+
+echo "Switching to main..."
+# Use checkout for POSIX sh compatibility
+git checkout main
+
+echo "Fast-forwarding main to origin/main..."
+# Strictly fast-forward to avoid accidental merge commits
+git merge --ff-only origin/main
+
+# Decide delete mode
+DELETE_FLAG="-d"
+if [ "${FORCE}" -eq 1 ]; then
+  DELETE_FLAG="-D"
+fi
+
+# Verify merged status when not forcing
+if [ "${FORCE}" -ne 1 ]; then
+  if git merge-base --is-ancestor "${CURRENT_BRANCH}" main; then
+    :
+  else
+    echo "Branch '${CURRENT_BRANCH}' is not merged into 'main'. Use -f to force delete." >&2
+    exit 1
+  fi
+fi
+
+echo "Deleting local branch '${CURRENT_BRANCH}' (${DELETE_FLAG})..."
+git branch "${DELETE_FLAG}" "${CURRENT_BRANCH}"
+
+if [ "${DEL_REMOTE}" -eq 1 ]; then
+  # Delete remote branch only if it exists
+  if git ls-remote --exit-code --heads origin "refs/heads/${CURRENT_BRANCH}" >/dev/null 2>&1; then
+    echo "Deleting remote branch 'origin/${CURRENT_BRANCH}'..."
+    git push origin --delete "${CURRENT_BRANCH}"
+  else
+    echo "Remote branch 'origin/${CURRENT_BRANCH}' not found; skipping."
+  fi
+fi
+
+echo "Done."

paddle-1.1.5/docker/scripts/git-send

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+MSG="${1:-wip}"
+
+# Ensure we're inside a git repo
+if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  echo "Not inside a git repository." >&2
+  exit 1
+fi
+
+# Resolve repo root and branch
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+cd "$REPO_ROOT"
+
+# Try the normal way; fall back if detached HEAD
+BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")"
+if [[ "$BRANCH" == "HEAD" || -z "$BRANCH" ]]; then
+  # Fallback: guess from upstream or default to 'main'
+  BRANCH="$(git symbolic-ref --short -q HEAD 2>/dev/null || echo main)"
+fi
+
+# Stage changes
+git add -A
+
+# Commit only if there’s something staged
+if ! git diff --cached --quiet; then
+  git commit -m "$MSG"
+else
+  echo "No staged changes; nothing to commit."
+fi
+
+# Ensure we have an upstream
+if ! git rev-parse --abbrev-ref --symbolic-full-name "@{u}" >/dev/null 2>&1; then
+  # If origin doesn't exist, error clearly
+  if ! git remote get-url origin >/dev/null 2>&1; then
+    echo "Remote 'origin' not configured. Set it first: git remote add origin <url>" >&2
+    exit 1
+  fi
+  git push -u origin "$BRANCH"
+else
+  # Rebase pull to avoid merge commits; allow autostash for local changes
+  git pull --rebase --autostash || true
+  git push
+fi

paddle-1.1.5/docker-compose.yaml

@@ -0,0 +1,29 @@
+services:
+  dev:
+    image: paddle
+    build:
+      context: .
+      dockerfile: docker/Dockerfile
+      args:
+        CUDA_VER: "12.9.1"
+        UBUNTU_VER: "22.04"
+    environment:
+      - USERNAME=${USER}
+      - USER_UID=${USER_UID}
+      - USER_GID=${USER_GID}
+    deploy:
+      resources:
+        reservations:
+          devices:
+            # If your system does not have gpu, remove it from the []
+            - capabilities: [gpu]
+    volumes:
+      # This is your main working directory
+      - ${HOME}/projects:/projects
+      # This is where you put your large simulation data
+      - ${HOME}/data/:/data
+    working_dir: /projects
+    tty: true
+    stdin_open: true
+    ports:
+      - "8888:8888"

{paddle-1.1.4 → paddle-1.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paddle"
-version = "1.1.4"
+version = "1.1.5"
 description = "Python Atmospheric Dynamics: Discovery and Learning about Exoplanets. An open-source, user-friendly python frontend of canoe"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -32,8 +32,8 @@ classifiers = [
 
 dependencies = [
   "torch>=2.7.0,<=2.7.1",
-  "kintera>=1.0.1",
-  "snapy>=0.7.0",
+  "kintera>=1.1.5",
+  "snapy>=0.8.2",
 ]
 
 [project.optional-dependencies]

{paddle-1.1.4 → paddle-1.1.5}/src/paddle/__init__.py

@@ -4,4 +4,4 @@ from .find_init_params import find_init_params
 from .evolve_kinetics import evolve_kinetics
 
 __all__ = ["setup_profile", "write_profile", "find_init_params", "evolve_kinetics"]
-__version__ = "1.1.4"
+__version__ = "1.1.5"

paddle-1.1.5/src/paddle/nc2pt.py

@@ -0,0 +1,39 @@
+#! /usr/bin/env python3
+
+"""
+Read variables in a NetCDF file and write them to jit saved torch tensors.
+Usage: python nc2pt.py input.nc output.pt
+"""
+
+from netCDF4 import Dataset
+import torch
+
+
+def save_tensors(tensor_map: dict[str, torch.Tensor], filename: str):
+    class TensorModule(torch.nn.Module):
+        def __init__(self, tensors):
+            super().__init__()
+            for name, tensor in tensors.items():
+                self.register_buffer(name, tensor)
+
+    module = TensorModule(tensor_map)
+    scripted = torch.jit.script(module)  # Needed for LibTorch compatibility
+    scripted.save(filename)
+
+
+fname = "sod.out0.00019.nc"
+
+nc = Dataset(fname, "r")
+out_fname = "sod.out0.00019.pt"
+
+data = {}
+for varname in nc.variables:
+    var = nc.variables[varname][:]
+    if var.ndim == 4:  # (time, x1, x2, x3) -> (time, x3, x2, x1)
+        data[varname] = torch.tensor(var).permute(0, 3, 2, 1).squeeze()
+    elif var.ndim == 3:  # (x1, x2, x3) -> (x3, x2, x1)
+        data[varname] = torch.tensor(var).permute(2, 1, 0).squeeze()
+    else:
+        data[varname] = torch.tensor(var).squeeze()
+
+save_tensors(data, out_fname)

paddle-1.1.5/src/paddle/pt2nc.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Convert a sequence of PyTorch .pt dumps into a CF‐compliant NetCDF4 file
+with dimensions (time, x, y, z) plus a 'species' axis for mole fractions.
+"""
+
+import os
+import tarfile
+import re
+import torch
+import numpy as np
+from datetime import datetime
+from netCDF4 import Dataset
+
+# ──────────────────────────────── CONFIG ────────────────────────────────
+INPUT_DIR = "."
+OUTPUT_FILE = "thermo_x_xfrac_to_conc.nc"
+# ────────────────────────────────────────────────────────────────────────
+
+# find all .pt files, skip size==0, sort by timestamp
+pt_files = []
+for fn in os.listdir(INPUT_DIR):
+    if not fn.endswith(".pt"):
+        continue
+    full = os.path.join(INPUT_DIR, fn)
+    if os.path.getsize(full) == 0:
+        continue
+    # expect names like thermo_x_xfrac_to_conc_<epoch>.pt
+    m = re.search(r"(\d+)\.pt$", fn)
+    if not m:
+        continue
+    pt_files.append((int(m.group(1)), full))
+
+pt_files.sort(key=lambda x: x[0])
+times_epoch = [ts for ts, _ in pt_files]
+
+# load the first file to infer shapes
+module = torch.jit.load(pt_files[0][1])
+data = {name: param for name, param in module.named_parameters()}
+
+temp0 = data["temp"].numpy()
+pres0 = data["pres"].numpy()
+xfrac0 = data["xfrac"].numpy()
+nx3, nx2, nx1 = temp0.shape
+nspecies = xfrac0.shape[3]
+nt = len(pt_files)
+
+# pre‐allocate arrays in (time, x1, x2, x3) order
+temp_arr = np.empty((nt, nx1, nx2, nx3), dtype=temp0.dtype)
+pres_arr = np.empty((nt, nx1, nx2, nx3), dtype=pres0.dtype)
+xfrac_arr = np.empty((nspecies, nt, nx1, nx2, nx3), dtype=xfrac0.dtype)
+
+# load all timesteps
+for i, (_, path) in enumerate(pt_files):
+    module = torch.jit.load(path)
+    data = {name: param for name, param in module.named_parameters()}
+    t_np = data["temp"].numpy()  # (z, y, x)
+    p_np = data["pres"].numpy()  # (z, y, x)
+    x_np = data["xfrac"].numpy()  # (species, z, y, x)
+
+    # reorder to (x, y, z)
+    temp_arr[i] = t_np.transpose(2, 1, 0)
+    pres_arr[i] = p_np.transpose(2, 1, 0)
+    for j in range(nspecies):
+        xfrac_arr[j, i] = x_np[:, :, :, j].transpose(2, 1, 0)
+
+# create NetCDF4 file
+ds = Dataset(OUTPUT_FILE, "w", format="NETCDF4")
+
+# dimensions
+ds.createDimension("time", nt)
+ds.createDimension("x3", nx3)
+ds.createDimension("x2", nx2)
+ds.createDimension("x1", nx1)
+
+# coordinate variables
+tvar = ds.createVariable("time", "f4", ("time",))
+tvar.units = "seconds since 1970-01-01 00:00:00 UTC"
+tvar.calendar = "gregorian"
+tvar[:] = np.array(times_epoch, dtype="f4")
+
+zvar = ds.createVariable("x1", "f4", ("x1",))
+yvar = ds.createVariable("x2", "f4", ("x2",))
+xvar = ds.createVariable("x3", "f4", ("x3",))
+
+xvar.axis = "X"
+yvar.axis = "Y"
+zvar.axis = "Z"
+
+xvar[:] = np.arange(nx3)
+yvar[:] = np.arange(nx2)
+zvar[:] = np.arange(nx1)
+
+# data variables
+temp_v = ds.createVariable("temp", "f4", ("time", "x1", "x2", "x3"), zlib=True)
+temp_v.units = "K"
+temp_v.long_name = "temperature"
+
+pres_v = ds.createVariable("pres", "f4", ("time", "x1", "x2", "x3"), zlib=True)
+pres_v.units = "Pa"
+pres_v.long_name = "pressure"
+
+xfrac_v = []
+for i in range(nspecies):
+    xfrac_v.append(
+        ds.createVariable(f"xfrac{i}", "f4", ("time", "x1", "x2", "x3"), zlib=True)
+    )
+    xfrac_v[i].units = "1"
+    xfrac_v[i].long_name = "mole fraction of each species"
+
+# write the data
+temp_v[:] = temp_arr
+pres_v[:] = pres_arr
+for i in range(nspecies):
+    xfrac_v[i][:] = xfrac_arr[i]
+
+# global metadata
+ds.title = "Debug fields for thermo_x.xfrac_to_conc"
+ds.institution = "University of Michigan"
+ds.source = "converted from .pt files"
+ds.history = f"Created {datetime.utcnow().isoformat()}Z"
+
+ds.close()
+print(f"Converted file: {OUTPUT_FILE}")

{paddle-1.1.4 → paddle-1.1.5}/src/paddle/setup_profile.py

@@ -140,7 +140,10 @@ def integrate_dry_adiabat(
 
 
 def setup_profile(
-    block: snapy.MeshBlock, param: dict[str, float] = {}, method: str = "moist-adiabat"
+    block: snapy.MeshBlock,
+    param: dict[str, float] = {},
+    method: str = "moist-adiabat",
+    verbose: bool = False,
 ) -> torch.Tensor:
     """
     Set up an adiabatic initial condition for the mesh block.
@@ -227,7 +230,7 @@ def setup_profile(
     dz = coord.buffer("dx1f")[ifirst]
 
     # half a grid to cell center
-    thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz / 2.0)
+    thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz / 2.0, verbose=verbose)
 
     # adiabatic extrapolation
     if method == "isothermal":
@@ -257,7 +260,7 @@ def setup_profile(
         elif method.split("-")[0] == "neutral":
             temp, pres, xfrac = integrate_neutral(thermo_x, temp, pres, xfrac, grav, dz)
         else:
-            thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz)
+            thermo_x.extrapolate_ad(temp, pres, xfrac, grav, dz, verbose=verbose)
 
         if torch.any(temp < Tmin):
             i_isothermal = i + 1

paddle-1.1.5/tests/.gitignore

@@ -0,0 +1,2 @@
+# test output
+*.txt

{paddle-1.1.4 → paddle-1.1.5}/tests/test_saturn_adiabat.py

@@ -9,11 +9,12 @@ from snapy import (
     MeshBlock,
 )
 from kintera import ThermoX
+from pathlib import Path
 
 
 def setup_saturn_profile():
     # path = resources.files("paddle") / "data" / "saturn1d.yaml"
-    path = "data" / "saturn1d.yaml"
+    path = Path("data") / "saturn1d.yaml"
     print(f"Reading input file: {path}")
 
     op_block = MeshBlockOptions.from_yaml(str(path))
@@ -41,7 +42,7 @@ def setup_saturn_profile():
         method=method,
         max_iter=50,
         ftol=1.0e-2,
-        verbose=True,
+        verbose=False,
     )
 
     w = setup_profile(block, param, method=method)

paddle-1.1.4/README.md

@@ -1,2 +0,0 @@
-# paddle
-Python Atmospheric Dynamics: Discovering and Learning about Exoplanets. An open-source, user-friendly python version of canoe.