flapjax-model-gen 0.1.0__tar.gz

flapjax_model_gen-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,42 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v10.2.0
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/flapjax-model-gen
+    permissions:
+      id-token: write # required for PyPI trusted publishing (OIDC) -- no API token secret needed
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

flapjax_model_gen-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+dist/
+build/
+.python-version
+.idea/

flapjax_model_gen-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026, Loads Control and Aeroelastics, Imperial College London
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flapjax_model_gen-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.5
+Name: flapjax-model-gen
+Version: 0.1.0
+Summary: Match strip-wise aerodynamic corrections (cl0/cla/cm0/cma) to a NASTRAN-ready twist distribution using flapjax.
+Author-email: Ben Preston <b.preston23@imperial.ac.uk>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aeroelasticity,flapjax,nastran,vortex lattice method
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.12
+Requires-Dist: flapjax>=1.3.6
+Requires-Dist: jax>=0.8.1
+Requires-Dist: pynastran>=1.3.4
+Description-Content-Type: text/markdown
+
+# flapjax-model-gen
+
+Match strip-wise aerodynamic corrections (`cl0`, `cla`, `cm0`, `cma`) — defined about an aircraft's flight
+shape, with no knowledge of local angle of attack or elastic deformation — to a NASTRAN-ready aerodynamic twist
+distribution, using [flapjax](https://github.com/ben-l-p/flapjax) as the differentiable solver in the loop.
+
+This is a thin, fast-moving companion package to `flapjax`, kept separate so it can be iterated on and released
+independently.
+
+## What's here
+
+Most of the workflow this package supports is already implemented in `flapjax` itself
+(`flapjax.aero.utils.apply_polar_correction` / `strip_alpha` / `project_forcing_to_beam`, wired into `UVLM` via
+its `polar_data` / `polar_function` arguments — see `flapjax`'s `models/cantilever_wing/polar_correction.ipynb`
+tutorial). This package adds the pieces that were missing:
+
+- `linear_polar.py` — a `PolarFunction` (`flapjax`'s `(alpha, data) -> (cl, cd, cm)` interface) that evaluates
+  an affine correction, `cl = cl0 + cla * alpha`, `cm = cm0 + cma * alpha`, `cd = 0`, so `cl0`/`cla`/`cm0`/`cma`
+  data can be dropped straight into `UVLM(polar_data=..., polar_function=...)` exactly like a tabulated polar.
+- `rigid.py` — rigidly rotates a structure's reference SE(3) frames (`rotate_hg`), for representing a change in
+  angle of attack as a *rotation of the geometry*, matching the correction data's own convention, rather than
+  rotating the freestream direction.
+- `twist_grid.py` — `make_twisted_grid`, a per-spanwise-station generalisation of `flapjax`'s
+  `make_rectangular_grid(..., twist=...)` (which applies one scalar twist to the whole grid). This is the search
+  space the optimizer below works in.
+- `strip_forces.py` — thin helpers around `AeroCase.project_forcing_to_beam` for pulling global-frame,
+  per-node force/moment vectors out of a solved case, on either the rigid reference shape or a deformed one.
+- `twist_match.py` — `match_twist`, a JAX-native Levenberg-Marquardt solver (autodiff Jacobian,
+  `jax.lax.while_loop`) that finds the twist distribution minimising the residual between a candidate model's
+  forces and a target force field. This is the genuinely new piece: no optimizer for this existed in `flapjax`.
+
+## Suggested workflow
+
+This mirrors the four-step process it was built for; wire the pieces together to fit your model rather than
+treating this as a locked pipeline — in particular, **check the assumption flagged in step 3** before trusting
+the result.
+
+```python
+import jax.numpy as jnp
+from flapjax.aero import ConstantFlowField
+from flapjax_model_gen import (
+    LinearPolar, linear_polar_function, rotate_hg, rigid_corrected_forces,
+    make_twisted_grid, match_twist,
+)
+
+# 1. Target forces directly from the correction data, on the rigid, undeformed flight shape.
+#    `uvlm_corrected` is your UVLM/CoupledAeroelastic built with
+#    polar_data=[LinearPolar(cl0, cla, cm0, cma)], polar_function=[linear_polar_function].
+target_0 = rigid_corrected_forces(uvlm_corrected, hg=structure.hg0)
+target_1 = rigid_corrected_forces(uvlm_corrected, hg=rotate_hg(structure.hg0, jnp.deg2rad(1.0)))
+
+# 2. Static deformation under the corrected aero at AoA=0 (full FSI solve).
+sol_0 = coupled_corrected.static_solve(prescribed_dofs=range(6), horseshoe=True)
+
+# 3. Rigidly rotate the *converged, deformed* shape and take a single (no-FSI) aero pass at AoA=1.
+#    NOTE: apply_polar_correction evaluates cl0/cla/cm0/cma at each strip's *locally computed* AoA, which in a
+#    coupled solve includes any elastic twist -- extrapolating a correction that was only derived from rigid
+#    sweeps. That's usually the intended reading of "sectional" data, but confirm it before relying on it.
+hg_1 = rotate_hg(sol_0.structure.hg, jnp.deg2rad(1.0))
+model_1 = rigid_corrected_forces(uvlm_corrected, hg=hg_1)
+
+# 4. Build an *uncorrected* aero model with per-station twist as the free variable, and match it (on the same,
+#    fixed deformed geometry from step 2/3) against whichever of the above you're treating as ground truth.
+def forces_fn(twist):
+    x0_aero = [make_twisted_grid(m, n, chord, ea, twist=twist)]
+    uvlm_plain.set_design_variables(..., x0_aero=x0_aero)
+    f0 = rigid_corrected_forces(uvlm_plain, hg=structure.hg0)
+    f1 = rigid_corrected_forces(uvlm_plain, hg=rotate_hg(sol_0.structure.hg, jnp.deg2rad(1.0)))
+    return jnp.stack([f0, f1])
+
+target = jnp.stack([target_0, target_1])
+result = match_twist(forces_fn, target, twist0=jnp.zeros(n + 1))
+```
+
+A single per-strip twist angle is a pure shift of local incidence: it can reproduce a `cl0`-like offset against
+whatever lift-curve slope the plain panel aerodynamics already has, but it cannot independently fix a
+mismatched `cla`, and it can't inject an independent camber-driven `cm0` (a flat panel has no camber). Worth
+checking that the plain UVLM's native `cla` per strip is already close to the target before trusting the fit —
+if it isn't, geometry/discretisation needs adjusting, not just twist.
+
+## Building a flapjax model from NASTRAN inputs
+
+`flapjax_model_gen.nastran` converts a NASTRAN aircraft model into flapjax `BeamStructure`/`UVLM` inputs, using
+[pyNastran](https://github.com/SteveDoyle2/pyNastran) to parse bulk data. It expects three input files, matching
+how these models are actually organised:
+
+- **Aerodynamic mesh** (`.bdf`, `CAERO1` panels) — `nastran.parse_caero1_panels` extracts each panel's leading/
+  trailing-edge corner points (already resolved to the global frame, including its own `CP` coordinate system);
+  `nastran.build_local_grid` then rediscretizes them into a flapjax local grid.
+- **Mass model** (one or more `.nsb` files, `CONM2` entries only — e.g. one structural, one fuel) —
+  `nastran.parse_mass_files` sums them into one lumped 6x6 mass matrix per node.
+- **Stiffness model** (`.bdf`, `GRID` + `CBEAM` + `PBEAM`, referencing `MAT1`) — `nastran.parse_stiffness_bdf`
+  builds node coordinates, connectivity, per-element orientation (`y_vector`) and per-element 6x6 stiffness.
+
+```python
+import jax.numpy as jnp
+from flapjax.aero import GridDiscretisation, UVLM
+from flapjax.structure import BeamStructure
+from flapjax.coupled import CoupledAeroelastic
+from flapjax_model_gen.nastran import (
+    parse_stiffness_bdf, parse_mass_files, read_aero_bdf, parse_caero1_panels, build_local_grid,
+)
+
+beam_model = parse_stiffness_bdf("stiffness.bdf")
+m_lumped, m_lumped_index = parse_mass_files(["structure.nsb", "fuel.nsb"], node_ids=beam_model.node_ids)
+
+structure = BeamStructure(
+    num_nodes=len(beam_model.node_ids),
+    connectivity=beam_model.connectivity,
+    y_vector=beam_model.y_vector,
+    k_cs_index=beam_model.k_cs_index,
+    m_lumped_index=m_lumped_index,
+)
+
+aero_model = read_aero_bdf("aero.bdf")
+panels = parse_caero1_panels(aero_model)  # group/order multi-panel surfaces yourself, e.g. sorted by span
+local_grid = build_local_grid(panels, beam_model.coords, m=8, span_axis=1)
+
+uvlm = UVLM(
+    grid_shapes=[GridDiscretisation(m=8, n=len(beam_model.node_ids) - 1, m_star=20)],
+    dof_mapping=jnp.arange(len(beam_model.node_ids)),
+)
+wing = CoupledAeroelastic(structure, uvlm)
+wing.set_design_variables(
+    coords=beam_model.coords, k_cs=beam_model.k_cs, m_cs=None, m_lumped=m_lumped,
+    dt=..., flowfield=..., x0_aero=[local_grid],
+)
+```
+
+**What's deliberately out of scope / assumed**, each backed by a clear error or warning rather than a silent
+wrong answer if violated:
+
+- Only `CAERO1`, `CBEAM`/`PBEAM` (not `PBEAML`/`PBCOMP`), and `MAT1` are supported.
+- `CBEAM`'s `OFFT` must be the default `'GGG'`, and end offsets (`WA`/`WB`) must be zero — no offset beam ends.
+- `CONM2`'s `CID` must be the basic coordinate system (`0` or `-1`).
+- A tapered `PBEAM` (multiple stations) is collapsed to one constant cross-section per element by averaging its
+  station values — flapjax elements are constant-property, so this is an approximation for a genuinely tapered
+  element, not a limitation you can configure around.
+- `PBEAM`'s `I12` (bend-bend coupling) is not incorporated into `k_cs` — a warning fires if it's nonzero, since
+  results will be approximate for that element.
+- The aerodynamic grid's spanwise stations are placed exactly at the given structural node positions (flapjax's
+  `dof_mapping` ties each aero column rigidly to one structural node, with no separate spline layer like
+  NASTRAN's beam splines) — `build_local_grid` doesn't take an independent spanwise panel count.
+- The axis convention (`CBEAM`'s orientation vector = flapjax's `y_vector` directly; PBEAM `I1`→bending about
+  local z, `I2`→about local y) was verified against the NASTRAN QRG and cross-checked against flapjax's own
+  beam code, not assumed — see the docstring in `nastran/stiffness.py` for the derivation.
+
+## Development
+
+```bash
+uv sync --dev
+uv run pytest
+uv run ruff check src
+```
+
+Tests are deliberately lightweight (geometry/algebra invariants and a synthetic least-squares problem for the
+optimizer) rather than full aeroelastic solves, so the suite stays fast to iterate against.

flapjax_model_gen-0.1.0/README.md

@@ -0,0 +1,157 @@
+# flapjax-model-gen
+
+Match strip-wise aerodynamic corrections (`cl0`, `cla`, `cm0`, `cma`) — defined about an aircraft's flight
+shape, with no knowledge of local angle of attack or elastic deformation — to a NASTRAN-ready aerodynamic twist
+distribution, using [flapjax](https://github.com/ben-l-p/flapjax) as the differentiable solver in the loop.
+
+This is a thin, fast-moving companion package to `flapjax`, kept separate so it can be iterated on and released
+independently.
+
+## What's here
+
+Most of the workflow this package supports is already implemented in `flapjax` itself
+(`flapjax.aero.utils.apply_polar_correction` / `strip_alpha` / `project_forcing_to_beam`, wired into `UVLM` via
+its `polar_data` / `polar_function` arguments — see `flapjax`'s `models/cantilever_wing/polar_correction.ipynb`
+tutorial). This package adds the pieces that were missing:
+
+- `linear_polar.py` — a `PolarFunction` (`flapjax`'s `(alpha, data) -> (cl, cd, cm)` interface) that evaluates
+  an affine correction, `cl = cl0 + cla * alpha`, `cm = cm0 + cma * alpha`, `cd = 0`, so `cl0`/`cla`/`cm0`/`cma`
+  data can be dropped straight into `UVLM(polar_data=..., polar_function=...)` exactly like a tabulated polar.
+- `rigid.py` — rigidly rotates a structure's reference SE(3) frames (`rotate_hg`), for representing a change in
+  angle of attack as a *rotation of the geometry*, matching the correction data's own convention, rather than
+  rotating the freestream direction.
+- `twist_grid.py` — `make_twisted_grid`, a per-spanwise-station generalisation of `flapjax`'s
+  `make_rectangular_grid(..., twist=...)` (which applies one scalar twist to the whole grid). This is the search
+  space the optimizer below works in.
+- `strip_forces.py` — thin helpers around `AeroCase.project_forcing_to_beam` for pulling global-frame,
+  per-node force/moment vectors out of a solved case, on either the rigid reference shape or a deformed one.
+- `twist_match.py` — `match_twist`, a JAX-native Levenberg-Marquardt solver (autodiff Jacobian,
+  `jax.lax.while_loop`) that finds the twist distribution minimising the residual between a candidate model's
+  forces and a target force field. This is the genuinely new piece: no optimizer for this existed in `flapjax`.
+
+## Suggested workflow
+
+This mirrors the four-step process it was built for; wire the pieces together to fit your model rather than
+treating this as a locked pipeline — in particular, **check the assumption flagged in step 3** before trusting
+the result.
+
+```python
+import jax.numpy as jnp
+from flapjax.aero import ConstantFlowField
+from flapjax_model_gen import (
+    LinearPolar, linear_polar_function, rotate_hg, rigid_corrected_forces,
+    make_twisted_grid, match_twist,
+)
+
+# 1. Target forces directly from the correction data, on the rigid, undeformed flight shape.
+#    `uvlm_corrected` is your UVLM/CoupledAeroelastic built with
+#    polar_data=[LinearPolar(cl0, cla, cm0, cma)], polar_function=[linear_polar_function].
+target_0 = rigid_corrected_forces(uvlm_corrected, hg=structure.hg0)
+target_1 = rigid_corrected_forces(uvlm_corrected, hg=rotate_hg(structure.hg0, jnp.deg2rad(1.0)))
+
+# 2. Static deformation under the corrected aero at AoA=0 (full FSI solve).
+sol_0 = coupled_corrected.static_solve(prescribed_dofs=range(6), horseshoe=True)
+
+# 3. Rigidly rotate the *converged, deformed* shape and take a single (no-FSI) aero pass at AoA=1.
+#    NOTE: apply_polar_correction evaluates cl0/cla/cm0/cma at each strip's *locally computed* AoA, which in a
+#    coupled solve includes any elastic twist -- extrapolating a correction that was only derived from rigid
+#    sweeps. That's usually the intended reading of "sectional" data, but confirm it before relying on it.
+hg_1 = rotate_hg(sol_0.structure.hg, jnp.deg2rad(1.0))
+model_1 = rigid_corrected_forces(uvlm_corrected, hg=hg_1)
+
+# 4. Build an *uncorrected* aero model with per-station twist as the free variable, and match it (on the same,
+#    fixed deformed geometry from step 2/3) against whichever of the above you're treating as ground truth.
+def forces_fn(twist):
+    x0_aero = [make_twisted_grid(m, n, chord, ea, twist=twist)]
+    uvlm_plain.set_design_variables(..., x0_aero=x0_aero)
+    f0 = rigid_corrected_forces(uvlm_plain, hg=structure.hg0)
+    f1 = rigid_corrected_forces(uvlm_plain, hg=rotate_hg(sol_0.structure.hg, jnp.deg2rad(1.0)))
+    return jnp.stack([f0, f1])
+
+target = jnp.stack([target_0, target_1])
+result = match_twist(forces_fn, target, twist0=jnp.zeros(n + 1))
+```
+
+A single per-strip twist angle is a pure shift of local incidence: it can reproduce a `cl0`-like offset against
+whatever lift-curve slope the plain panel aerodynamics already has, but it cannot independently fix a
+mismatched `cla`, and it can't inject an independent camber-driven `cm0` (a flat panel has no camber). Worth
+checking that the plain UVLM's native `cla` per strip is already close to the target before trusting the fit —
+if it isn't, geometry/discretisation needs adjusting, not just twist.
+
+## Building a flapjax model from NASTRAN inputs
+
+`flapjax_model_gen.nastran` converts a NASTRAN aircraft model into flapjax `BeamStructure`/`UVLM` inputs, using
+[pyNastran](https://github.com/SteveDoyle2/pyNastran) to parse bulk data. It expects three input files, matching
+how these models are actually organised:
+
+- **Aerodynamic mesh** (`.bdf`, `CAERO1` panels) — `nastran.parse_caero1_panels` extracts each panel's leading/
+  trailing-edge corner points (already resolved to the global frame, including its own `CP` coordinate system);
+  `nastran.build_local_grid` then rediscretizes them into a flapjax local grid.
+- **Mass model** (one or more `.nsb` files, `CONM2` entries only — e.g. one structural, one fuel) —
+  `nastran.parse_mass_files` sums them into one lumped 6x6 mass matrix per node.
+- **Stiffness model** (`.bdf`, `GRID` + `CBEAM` + `PBEAM`, referencing `MAT1`) — `nastran.parse_stiffness_bdf`
+  builds node coordinates, connectivity, per-element orientation (`y_vector`) and per-element 6x6 stiffness.
+
+```python
+import jax.numpy as jnp
+from flapjax.aero import GridDiscretisation, UVLM
+from flapjax.structure import BeamStructure
+from flapjax.coupled import CoupledAeroelastic
+from flapjax_model_gen.nastran import (
+    parse_stiffness_bdf, parse_mass_files, read_aero_bdf, parse_caero1_panels, build_local_grid,
+)
+
+beam_model = parse_stiffness_bdf("stiffness.bdf")
+m_lumped, m_lumped_index = parse_mass_files(["structure.nsb", "fuel.nsb"], node_ids=beam_model.node_ids)
+
+structure = BeamStructure(
+    num_nodes=len(beam_model.node_ids),
+    connectivity=beam_model.connectivity,
+    y_vector=beam_model.y_vector,
+    k_cs_index=beam_model.k_cs_index,
+    m_lumped_index=m_lumped_index,
+)
+
+aero_model = read_aero_bdf("aero.bdf")
+panels = parse_caero1_panels(aero_model)  # group/order multi-panel surfaces yourself, e.g. sorted by span
+local_grid = build_local_grid(panels, beam_model.coords, m=8, span_axis=1)
+
+uvlm = UVLM(
+    grid_shapes=[GridDiscretisation(m=8, n=len(beam_model.node_ids) - 1, m_star=20)],
+    dof_mapping=jnp.arange(len(beam_model.node_ids)),
+)
+wing = CoupledAeroelastic(structure, uvlm)
+wing.set_design_variables(
+    coords=beam_model.coords, k_cs=beam_model.k_cs, m_cs=None, m_lumped=m_lumped,
+    dt=..., flowfield=..., x0_aero=[local_grid],
+)
+```
+
+**What's deliberately out of scope / assumed**, each backed by a clear error or warning rather than a silent
+wrong answer if violated:
+
+- Only `CAERO1`, `CBEAM`/`PBEAM` (not `PBEAML`/`PBCOMP`), and `MAT1` are supported.
+- `CBEAM`'s `OFFT` must be the default `'GGG'`, and end offsets (`WA`/`WB`) must be zero — no offset beam ends.
+- `CONM2`'s `CID` must be the basic coordinate system (`0` or `-1`).
+- A tapered `PBEAM` (multiple stations) is collapsed to one constant cross-section per element by averaging its
+  station values — flapjax elements are constant-property, so this is an approximation for a genuinely tapered
+  element, not a limitation you can configure around.
+- `PBEAM`'s `I12` (bend-bend coupling) is not incorporated into `k_cs` — a warning fires if it's nonzero, since
+  results will be approximate for that element.
+- The aerodynamic grid's spanwise stations are placed exactly at the given structural node positions (flapjax's
+  `dof_mapping` ties each aero column rigidly to one structural node, with no separate spline layer like
+  NASTRAN's beam splines) — `build_local_grid` doesn't take an independent spanwise panel count.
+- The axis convention (`CBEAM`'s orientation vector = flapjax's `y_vector` directly; PBEAM `I1`→bending about
+  local z, `I2`→about local y) was verified against the NASTRAN QRG and cross-checked against flapjax's own
+  beam code, not assumed — see the docstring in `nastran/stiffness.py` for the derivation.
+
+## Development
+
+```bash
+uv sync --dev
+uv run pytest
+uv run ruff check src
+```
+
+Tests are deliberately lightweight (geometry/algebra invariants and a synthetic least-squares problem for the
+optimizer) rather than full aeroelastic solves, so the suite stays fast to iterate against.

flapjax_model_gen-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "flapjax-model-gen"
+version = "0.1.0"
+description = "Match strip-wise aerodynamic corrections (cl0/cla/cm0/cma) to a NASTRAN-ready twist distribution using flapjax."
+authors = [{ name = "Ben Preston", email = "b.preston23@imperial.ac.uk" }]
+keywords = ["aeroelasticity", "nastran", "vortex lattice method", "flapjax"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+requires-python = ">=3.12"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "flapjax>=1.3.6",
+    "jax>=0.8.1",
+    "pynastran>=1.3.4",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0",
+    "ruff>=0.15",
+]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+testpaths = ["tests"]
+python_files = ["test*.py"]
+addopts = "-q --tb=short"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/flapjax_model_gen"]

flapjax_model_gen-0.1.0/src/flapjax_model_gen/__init__.py

@@ -0,0 +1,20 @@
+from flapjax_model_gen.linear_polar import LinearPolar, linear_polar_function
+from flapjax_model_gen.rigid import PITCH_AXIS_DEFAULT, rotate_hg
+from flapjax_model_gen.strip_forces import (
+    rigid_corrected_forces,
+    strip_forces_from_aero,
+)
+from flapjax_model_gen.twist_grid import make_twisted_grid
+from flapjax_model_gen.twist_match import TwistMatchResult, match_twist
+
+__all__ = [
+    "PITCH_AXIS_DEFAULT",
+    "LinearPolar",
+    "TwistMatchResult",
+    "linear_polar_function",
+    "make_twisted_grid",
+    "match_twist",
+    "rigid_corrected_forces",
+    "rotate_hg",
+    "strip_forces_from_aero",
+]

flapjax_model_gen-0.1.0/src/flapjax_model_gen/linear_polar.py

@@ -0,0 +1,47 @@
+r"""
+Represent a strip-wise, rigid-shape aerodynamic correction (``cl0``, ``cla``, ``cm0``, ``cma``) as a flapjax
+``PolarFunction``, so it can be passed straight into ``UVLM(polar_data=..., polar_function=...)`` /
+``apply_polar_correction`` alongside (or instead of) a tabulated airfoil polar.
+
+These coefficients define an affine ``cl(alpha) = cl0 + cla * alpha`` and ``cm(alpha) = cm0 + cma * alpha`` about
+the quarter-chord, with no drag term (``cd`` is left at zero) since the source data has none. Because
+``apply_polar_correction`` samples this function at each strip's *locally computed* angle of attack -- which, in
+a coupled solve, includes any elastic contribution -- using it inside ``CoupledAeroelastic.static_solve`` is an
+explicit extrapolation of a correction that was itself derived only from rigid-body rotations of the flight
+shape. That is usually the intended behaviour (treating the coefficients as sectional/local data), but it is an
+assumption worth confirming rather than a given.
+"""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+from jax import Array
+from jax import numpy as jnp
+
+
+class LinearPolar(NamedTuple):
+    r"""Per-strip affine lift/moment correction, about the quarter-chord.
+    :param cl0: Lift coefficient at zero angle of attack, ``(n_strip,)``.
+    :param cla: Lift-curve slope, per radian, ``(n_strip,)``.
+    :param cm0: Pitching-moment coefficient at zero angle of attack, ``(n_strip,)``.
+    :param cma: Pitching-moment slope, per radian, ``(n_strip,)``.
+    """
+
+    cl0: Array
+    cla: Array
+    cm0: Array
+    cma: Array
+
+
+def linear_polar_function(alpha: Array, data: LinearPolar) -> tuple[Array, Array, Array]:
+    r"""
+    ``PolarFunction`` sampling an affine ``cl(alpha)``/``cm(alpha)`` model instead of a tabulated curve.
+    :param alpha: Per-strip angle of attack, radians, ``(n_strip,)``.
+    :param data: Affine correction coefficients.
+    :return: ``(cl, cd, cm)``, each ``(n_strip,)``; ``cd`` is identically zero.
+    """
+    cl = data.cl0 + data.cla * alpha
+    cd = jnp.zeros_like(alpha)
+    cm = data.cm0 + data.cma * alpha
+    return cl, cd, cm

flapjax_model_gen-0.1.0/src/flapjax_model_gen/nastran/__init__.py

@@ -0,0 +1,23 @@
+from flapjax_model_gen.nastran.aero_mesh import (
+    CaeroPanel,
+    build_local_grid,
+    parse_caero1_panels,
+    read_aero_bdf,
+)
+from flapjax_model_gen.nastran.mass import parse_mass_files
+from flapjax_model_gen.nastran.stiffness import (
+    NastranBeamModel,
+    parse_stiffness_bdf,
+    read_stiffness_bdf,
+)
+
+__all__ = [
+    "CaeroPanel",
+    "NastranBeamModel",
+    "build_local_grid",
+    "parse_caero1_panels",
+    "parse_mass_files",
+    "parse_stiffness_bdf",
+    "read_aero_bdf",
+    "read_stiffness_bdf",
+]