diff --git a/.github/workflows/actions.yml b/.github/workflows/actions.yml index 7afd53b..2718c20 100644 --- a/.github/workflows/actions.yml +++ b/.github/workflows/actions.yml @@ -1,43 +1,44 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions +# Run the aframe test suite on pushes and pull requests to main. name: Tests -# Whenever there is a pull request (PR) or push to the "main" branch, the jobs specified below will run. -on: +on: push: branches: [ "main" ] pull_request: branches: [ "main" ] -# Here, we specify the automatic cloud based testing that will be ran on pushes/PRs to "main" jobs: - build: - - # The tests will run on ubuntu with python versions 3.8, 3.9, and 3.10. - # Add other OSes like windows and macOS if needed as well as other Python versions + test: runs-on: ubuntu-latest strategy: fail-fast: false matrix: - python-version: ["3.8", "3.9", "3.10"] + # the Python versions CSDL_alpha is tested on + python-version: ["3.9", "3.10"] steps: - # The steps here are essentially command-line arguments that will be ran on the cloud with the above configurations - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v3 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} + cache: pip + cache-dependency-path: pyproject.toml + + # virtual display for the off-screen PyVista plotting test + - name: Set up headless display + uses: pyvista/setup-headless-display-action@v3 - # Here we install the package of this repositories as well as other required packages - name: Install dependencies - run: | + run: | python -m pip install --upgrade pip - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install -e . + # CSDL_alpha is not on PyPI + pip install git+https://github.com/LSDOlab/CSDL_alpha.git + # optional: runs the JAX backend test (tests/test_jax.py) + pip install jax + pip install -e ".[dev,plot]" - # Finally, we run the package unit-tests on the specified OS and python versions. - name: Test with pytest - run: | - pytest + run: pytest diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..045e29e --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,62 @@ +# Build the pdoc API documentation on every push and pull request, and publish +# it to GitHub Pages on pushes to main (https://lsdolab.github.io/aframe/). + +name: Docs + +on: + push: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +# one Pages deployment at a time; don't cancel a deployment in progress +concurrency: + group: docs-${{ github.ref }} + cancel-in-progress: false + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.10" + cache: pip + cache-dependency-path: pyproject.toml + + # PyVista is imported to document the plotting helpers + - name: Set up headless display + uses: pyvista/setup-headless-display-action@v3 + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + # CSDL_alpha is not on PyPI + pip install git+https://github.com/LSDOlab/CSDL_alpha.git + pip install -e ".[plot,docs]" + + - name: Build documentation + run: python docs/make_docs.py -o site + + - uses: actions/upload-pages-artifact@v3 + with: + path: site + + deploy: + # only the main branch is published + if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' + needs: build + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - id: deployment + uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore index a00158a..dfd05a1 100644 --- a/.gitignore +++ b/.gitignore @@ -1,144 +1,52 @@ -# Byte-compiled / optimized / DLL files +# Python bytecode __pycache__/ *.py[cod] *$py.class -# C extensions -*.so - -# Distribution / packaging -.Python +# Packaging / build artifacts build/ -develop-eggs/ dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ wheels/ -pip-wheel-metadata/ -share/python-wheels/ *.egg-info/ -.installed.cfg +.eggs/ *.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -.python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py +pip-wheel-metadata/ -# Environments +# Virtual environments .env -.venv +.venv/ env/ venv/ ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy +# Test, coverage and type-checker caches +.pytest_cache/ +.coverage +.coverage.* +htmlcov/ +.tox/ +.nox/ +.hypothesis/ .mypy_cache/ .dmypy.json dmypy.json - -# Pyre type checker .pyre/ +.ruff_cache/ -.DS_Store - -# Directory with files generated before building documentation -_temp - -# Sphinx -top_level_req.in -top_level_req.txt -_autosummary -_conf_master.py +# Jupyter +.ipynb_checkpoints/ +# Documentation builds +docs/_build/ +/site +# Solver / optimizer output (e.g. csdl JaxSimulator saves, modopt records) +*.hdf5 +*.h5 -.vscode/ \ No newline at end of file +# Editors and OS files +.vscode/ +.idea/ +*.swp +.DS_Store +Thumbs.db diff --git a/.readthedocs.yaml b/.readthedocs.yaml deleted file mode 100644 index 596552d..0000000 --- a/.readthedocs.yaml +++ /dev/null @@ -1,42 +0,0 @@ -# .readthedocs.yaml -# Read the Docs configuration file -# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details - -# Required -version: 2 - -# Set the version of Python and other tools you might need -build: - os: ubuntu-22.04 - tools: - python: "3.11" - # You can also specify other tool versions: - # nodejs: "19" - # rust: "1.64" - # golang: "1.19" - -# Build documentation in the docs/ directory with Sphinx -# To specify the path to the conf.py file, relative to the root of the project, -sphinx: - configuration: docs/conf.py - # Can also specify the builder type for the Sphinx documentation, and turn warnings into errors - # builder: html - # fail_on_warning: true - -# If using Sphinx, optionally build your docs in additional formats such as PDF -formats: - - pdf - - epub - - htmlzip - -# Optionally declare the Python requirements required to build your docs -python: - install: - - requirements: requirements.txt - - method: pip - path: . - -# If using a conda environment, -# add the path to the Conda environment file, relative to the root of the project. -# conda: -# environment: environment.yml diff --git a/README.md b/README.md index 89ac3d5..0247c0a 100644 --- a/README.md +++ b/README.md @@ -1,18 +1,290 @@ -# A linear beam solver written in CSDL +# aframe ![aframe](https://github.com/user-attachments/assets/02c7aae8-5a49-4ff5-8a16-f2b6295dab02) - +[![Tests](https://github.com/LSDOlab/aframe/actions/workflows/actions.yml/badge.svg)](https://github.com/LSDOlab/aframe/actions/workflows/actions.yml) +[![Docs](https://github.com/LSDOlab/aframe/actions/workflows/docs.yml/badge.svg)](https://lsdolab.github.io/aframe/) +[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/LSDOlab/aframe/blob/main/LICENSE.txt) -[![GitHub Actions Test Badge](https://github.com/LSDOlab/lsdo_project_template/actions/workflows/actions.yml/badge.svg)](https://github.com/lsdo_project_template/lsdo_project_template/actions) -[![Forks](https://img.shields.io/github/forks/LSDOlab/lsdo_project_template.svg)](https://github.com/LSDOlab/lsdo_project_template/network) -[![Issues](https://img.shields.io/github/issues/LSDOlab/lsdo_project_template.svg)](https://github.com/LSDOlab/lsdo_project_template/issues) +**aframe** is a linear finite-element solver for 3D beams and frames, written in +[CSDL](https://github.com/LSDOlab/CSDL_alpha). The code is written entirely in CSDL, so it is fully differentiable and well-suited for gradient-based design optimization and analysis. +**Features** +- 3D Euler-Bernoulli beam elements with 6 dofs per node and consistent mass matrices +- Frames of many beams connected by rigid joints, with fixed and pinned supports +- Nodal forces and moments, and inertial loads from a frame acceleration (e.g. gravity) and point masses +- Cross-sections: tube, box (wing box), solid circle, ellipse, or your own properties +- Stress recovery (von Mises) for tube and box sections +- Exact derivatives through CSDL, with the NumPy (inline) or JAX backend + +# Installation +aframe requires Python 3.9+ and [CSDL_alpha](https://github.com/LSDOlab/CSDL_alpha), which is not on PyPI, so install it first: +```bash +pip install git+https://github.com/LSDOlab/CSDL_alpha.git +git clone https://github.com/LSDOlab/aframe.git +pip install -e ./aframe +``` +Add extras as needed: `pip install -e "./aframe[plot]"` for the PyVista/Matplotlib plotting +helpers, `[dev]` for the tests and `[docs]` to build the documentation. Install `jax` to use +CSDL's JAX backend. + +# Quick start: a cantilever beam +A 10 m aluminum tube, clamped at the root, with a 1 kN tip load: + +```python +import numpy as np +import csdl_alpha as csdl +import aframe as af + +# record the model; inline=True evaluates values as the model is built +recorder = csdl.Recorder(inline=True) +recorder.start() + +# a 10 m cantilever along x with 21 nodes (20 elements) +num_nodes = 21 +mesh = np.zeros((num_nodes, 3)) +mesh[:, 0] = np.linspace(0, 10, num_nodes) + +# aluminum tube cross-section, one value per element +radius = csdl.Variable(value=np.full(num_nodes - 1, 0.1), name='radius') +thickness = csdl.Variable(value=np.full(num_nodes - 1, 0.005), name='thickness') +cs = af.CSTube(radius=radius, thickness=thickness) + +beam = af.Beam(name='cantilever', mesh=csdl.Variable(value=mesh), + E=69e9, G=26e9, density=2700, cs=cs) +beam.fix(0) # clamp the root node + +# nodal loads [Fx, Fy, Fz, Mx, My, Mz]: 1 kN downward at the tip +loads = np.zeros((num_nodes, 6)) +loads[-1, 2] = -1000 +beam.add_load(csdl.Variable(value=loads)) + +frame = af.Frame(beams=[beam]) +frame.solve() + +tip_deflection = frame.displacement['cantilever'][-1, 2] +stress = frame.compute_stress()['cantilever'] # von Mises, one value per element + +# derivatives of any output with respect to any input +d_deflection_d_radius = csdl.derivative(tip_deflection, radius) + +recorder.stop() + +print('tip deflection (m):', tip_deflection.value) +print('max stress (Pa):', stress.value.max()) +``` + +``` +tip deflection (m): [-0.33159692] +max stress (Pa): 66924549.00143065 +``` + +Both match beam theory: the tip deflection is PL³/3EI, and the maximum stress is the +bending stress M r / I at the midpoint of the root element (stresses are evaluated at +element midpoints). `d_deflection_d_radius` has shape (1, 20): the sensitivity of the +tip deflection to the radius of each element. + +# Building models +### Beams +`af.Beam(name, mesh, E, G, density, cs, z=False)` is a beam discretized into +`num_nodes - 1` elements between the nodes of `mesh` (shape `(num_nodes, 3)`). `E`, `G` +and `density` are the Young's modulus, shear modulus and density; use any consistent +units (the examples use SI). Beam names must be unique within a frame, since results +are keyed by name. + +Each element's local x axis points along the element. The standard construction of the +local y and z axes is singular for elements parallel to the global z axis, so **vertical +beams need `z=True`**. + +### Cross-sections +Section properties are per element, i.e. arrays of shape `(num_nodes - 1,)`, and can be +design variables. + +| Cross-section | Parameters | `stress()` | +|---|---|---| +| `af.CSTube` | `radius`, `thickness` | von Mises at the outer fiber, shape `(num_elements,)` | +| `af.CSBox` | `ttop`, `tbot`, `tweb`, `height`, `width` | von Mises at 4 corners and the web mid-height, shape `(num_elements, 5)` | +| `af.CSBox.from_properties` | box dimensions plus `area`, `ix`, `iy`, `iz` | as `CSBox` | +| `af.CSCircle` | `radius` | none | +| `af.CSEllipse` | `semi_major_axis`, `semi_minor_axis` | none | +| `af.CrossSection` | `area`, `ix`, `iy`, `iz` | none | + +`ix` is the torsion constant and `iy`, `iz` are the second moments of area about the +element's local y and z axes. To add a section type, subclass `af.CrossSection`, pass the +computed properties to `super().__init__`, and override `stress`. + +### Supports and loads +- `beam.fix(node)` clamps a node (all 6 dofs); `beam.pin(node)` fixes its translations only. +- `beam.add_load(loads)` sets the nodal loads, shape `(num_nodes, 6)`, ordered + `[Fx, Fy, Fz, Mx, My, Mz]` in global coordinates. Distributed loads must be lumped + to the nodes. +- `beam.add_inertial_mass(masses)` adds point masses at the nodes, shape `(num_nodes,)`. +- `af.Frame(..., acc=acc)` applies a frame acceleration `[ax, ay, az, αx, αy, αz]`, + shape `(6,)`, as inertial loads `M @ acc` on the structure and on the point masses. + Use `[0, 0, -9.81, 0, 0, 0]` for gravity. + +### Joints and frames +`af.Joint(members, nodes)` rigidly connects one node of each member (negative indices +count from the end of the beam). `af.Frame(beams, joints, acc)` assembles everything. +A portal frame under gravity and a lateral load: + +```python +import numpy as np +import csdl_alpha as csdl +import aframe as af + +recorder = csdl.Recorder(inline=True) +recorder.start() + +n = 11 + +def tube_beam(name, start, end, z=False): + mesh = csdl.Variable(value=np.linspace(start, end, n)) + cs = af.CSTube(radius=csdl.Variable(value=np.full(n - 1, 0.15)), + thickness=csdl.Variable(value=np.full(n - 1, 0.01))) + return af.Beam(name, mesh, E=69e9, G=26e9, density=2700, cs=cs, z=z) + +left = tube_beam('left', [0, 0, 0], [0, 0, 5], z=True) # vertical members need z=True +right = tube_beam('right', [8, 0, 0], [8, 0, 5], z=True) +top = tube_beam('top', [0, 0, 5], [8, 0, 5]) +left.fix(0) +right.fix(0) + +loads = np.zeros((n, 6)) +loads[n // 2, 1] = 5000 # 5 kN lateral load at midspan +top.add_load(csdl.Variable(value=loads)) + +joints = [af.Joint(members=[left, top], nodes=[-1, 0]), # rigid corners + af.Joint(members=[right, top], nodes=[-1, -1])] + +gravity = csdl.Variable(value=np.array([0, 0, -9.81, 0, 0, 0])) +frame = af.Frame(beams=[left, right, top], joints=joints, acc=gravity) +frame.solve() + +stress = frame.compute_stress() +cg, mass = frame.compute_mass_properties() + +recorder.stop() + +print('midspan displacement (m):', frame.displacement['top'].value[n // 2]) +print('max stress (Pa):', max(s.value.max() for s in stress.values())) +print('mass (kg):', mass.value, 'cg (m):', cg.value) +``` + +A beam can belong to several frames, e.g. for different joint layouts. + +### Results + +| Result | Description | +|---|---| +| `frame.displacement[name]`, `frame.rotation[name]` | Nodal displacements and rotations of a beam, shape `(num_nodes, 3)` (after `solve()`) | +| `frame.compute_stress(beams=None)` | Dict of per-beam stresses (see the cross-section table); pass `beams` to skip beams without a stress model | +| `frame.compute_mass_properties()` | Center of gravity `(3,)` and total mass of the beams (point masses excluded) | +| `beam.mass`, `beam.cg` | Mass and center of gravity of a beam | +| `frame.U`, `frame.K`, `frame.M`, `frame.F` | Global displacement vector, stiffness and mass matrices, and load vector | +| `frame.node_dofs(beam)` | Global dof indices of a beam's nodes, shape `(num_nodes, 6)`, e.g. for coupling to other solvers | + +All results are CSDL variables: read their `.value`, differentiate them with +`csdl.derivative`, or use them as objectives and constraints. + +# Optimization +Set inputs as design variables and outputs as objectives or constraints, then hand the +recorder to a CSDL simulator and an optimizer. A minimum-mass cantilever with stress and +deflection limits, using [modOpt](https://github.com/LSDOlab/modopt) and the JAX backend: + +```python +import numpy as np +import csdl_alpha as csdl +import aframe as af +from modopt import CSDLAlphaProblem, SLSQP + +recorder = csdl.Recorder(inline=True) +recorder.start() + +num_nodes = 21 +mesh = np.zeros((num_nodes, 3)) +mesh[:, 0] = np.linspace(0, 10, num_nodes) + +radius = csdl.Variable(value=np.full(num_nodes - 1, 0.1), name='radius') +radius.set_as_design_variable(lower=0.02, upper=0.5, scaler=10) +thickness = csdl.Variable(value=np.full(num_nodes - 1, 0.005), name='thickness') +thickness.set_as_design_variable(lower=0.001, upper=0.02, scaler=100) + +beam = af.Beam(name='cantilever', mesh=csdl.Variable(value=mesh), E=69e9, G=26e9, + density=2700, cs=af.CSTube(radius=radius, thickness=thickness)) +beam.fix(0) +loads = np.zeros((num_nodes, 6)) +loads[-1, 2] = -1000 +beam.add_load(csdl.Variable(value=loads)) + +frame = af.Frame(beams=[beam]) +frame.solve() + +stress = frame.compute_stress()['cantilever'] +stress.set_as_constraint(upper=100e6, scaler=1e-8) # 100 MPa allowable +tip_deflection = frame.displacement['cantilever'][-1, 2] +tip_deflection.set_as_constraint(lower=-0.2, scaler=10) # at most 0.2 m +beam.mass.set_as_objective(scaler=1e-2) + +recorder.stop() + +sim = csdl.experimental.JaxSimulator(recorder=recorder) +problem = CSDLAlphaProblem(problem_name='cantilever', simulator=sim) +optimizer = SLSQP(problem, solver_options={'maxiter': 200, 'ftol': 1e-8}, turn_off_outputs=True) +optimizer.solve() +optimizer.print_results() +``` + +`csdl.experimental.PySimulator(recorder)` runs the same model without JAX. See +[`examples/single_beam_opt.py`](https://github.com/LSDOlab/aframe/blob/main/examples/single_beam_opt.py) for a complete script. + +# Plotting +With the `plot` extra, the PyVista helpers draw beams into a `pyvista.Plotter`. For +example, the deformed cantilever from the quick start, colored by stress: + +```python +import pyvista as pv + +deformed = mesh + frame.displacement['cantilever'].value +plotter = pv.Plotter() +af.plot_mesh(plotter, deformed, cell_data=stress.value, line_width=10) +af.plot_points(plotter, deformed, point_size=15, color='black') +plotter.show() +``` + +`af.plot_cyl` and `af.plot_box` draw each element as a cylinder or box, and +`aframe.utils.plot_matplotlib` has Matplotlib equivalents. + +# Modeling assumptions +- Linear statics: small displacements and rotations, linear elastic material. +- Euler-Bernoulli elements (no shear deformation); cross-section properties are constant within an element. +- Joints are rigid and share all 6 dofs. +- Stresses are evaluated at element midpoints from the element internal loads. +- The global matrices are dense and solved with a dense direct solver, so time and memory grow + quickly with model size; models of up to a few thousand dofs (several hundred nodes) solve in + seconds. + +# Documentation +The API documentation is at **https://lsdolab.github.io/aframe/**. It is generated from the +docstrings with [pdoc](https://pdoc.dev) and republished on every push to `main`. To build it +locally: +```bash +pip install -e ".[plot,docs]" +python docs/make_docs.py +``` +and open `site/index.html`. + +# Examples +The [`examples`](https://github.com/LSDOlab/aframe/tree/main/examples) folder has complete scripts: + +| Script | What it shows | +|---|---| +| [`two_joined_beams.py`](https://github.com/LSDOlab/aframe/blob/main/examples/two_joined_beams.py) | Two tube beams connected by a joint | +| [`bingran_cantilever_beam.py`](https://github.com/LSDOlab/aframe/blob/main/examples/bingran_cantilever_beam.py) | A tube cantilever with stresses and mass properties | +| [`single_beam_opt.py`](https://github.com/LSDOlab/aframe/blob/main/examples/single_beam_opt.py) | Minimum-mass optimization with a displacement constraint (modOpt) | +| [`NASA_LPC_beam.py`](https://github.com/LSDOlab/aframe/blob/main/examples/NASA_LPC_beam.py), [`aurora_pav_vv.py`](https://github.com/LSDOlab/aframe/blob/main/examples/aurora_pav_vv.py) | Wing-box (`CSBox`) beams under spanwise load distributions | +| [`1_element_beam_test.py`](https://github.com/LSDOlab/aframe/blob/main/examples/1_element_beam_test.py) | Frames of single-element beams | +| [`ucsd_lunar_lander/`](https://github.com/LSDOlab/aframe/tree/main/examples/ucsd_lunar_lander) | A lunar lander frame with many joints, plotted with PyVista | +| [`bunny/`](https://github.com/LSDOlab/aframe/tree/main/examples/bunny) | A frame generated from the edges of an STL mesh | # License This project is licensed under the terms of the **MIT License**. diff --git a/aframe/__init__.py b/aframe/__init__.py index 7d976e2..1b7bc1b 100644 --- a/aframe/__init__.py +++ b/aframe/__init__.py @@ -1,9 +1,35 @@ -from aframe.core.cs import * -from aframe.core.frame import * -# from aframe.core.material import * -# from aframe.core import material +""" +aframe: a differentiable linear 3D beam/frame solver written in CSDL. + +.. include:: ../README.md + :start-line: 1 +""" +from aframe.core.cs import CrossSection, CSTube, CSCircle, CSEllipse, CSBox, CSBoxMarius from aframe.core.beam import Beam -from aframe.core.sim import * -from aframe.core.joint import * -from aframe.utils.plot_pyvista import * -from aframe.utils.meshing import * \ No newline at end of file +from aframe.core.joint import Joint +from aframe.core.frame import Frame +from aframe.utils.meshing import mesh_from_points_and_edges + +__version__ = '0.1.0' + +# the PyVista plotting helpers need the optional 'plot' dependencies and are +# slow to import, so they are loaded on first use +_PLOTTING = ('plot_box', 'plot_cyl', 'plot_mesh', 'plot_points') + +__all__ = ['CrossSection', 'CSTube', 'CSCircle', 'CSEllipse', 'CSBox', 'CSBoxMarius', + 'Beam', 'Joint', 'Frame', 'mesh_from_points_and_edges', *_PLOTTING] + + +def __getattr__(name): + if name in _PLOTTING: + try: + from aframe.utils import plot_pyvista + except ImportError as e: + raise ImportError(f"aframe.{name} needs pyvista and matplotlib: pip install aframe[plot]") from e + return getattr(plot_pyvista, name) + + raise AttributeError(f"module 'aframe' has no attribute {name!r}") + + +def __dir__(): + return sorted(set(globals()) | set(__all__)) diff --git a/aframe/core/__init__.py b/aframe/core/__init__.py index e69de29..a457e12 100644 --- a/aframe/core/__init__.py +++ b/aframe/core/__init__.py @@ -0,0 +1 @@ +"""Core model: cross-sections, beams, joints and the frame assembly/solve.""" diff --git a/aframe/core/beam.py b/aframe/core/beam.py index b2de165..e2a161d 100644 --- a/aframe/core/beam.py +++ b/aframe/core/beam.py @@ -1,68 +1,102 @@ +"""3D Euler-Bernoulli beam elements: stiffness, mass and coordinate transforms.""" +from __future__ import annotations +from typing import TYPE_CHECKING, List import numpy as np -import aframe as af import csdl_alpha as csdl -from typing import List +if TYPE_CHECKING: + from aframe.core.cs import CrossSection + +__all__ = ['Beam'] -class Beam: - def __init__(self, name:str, - mesh:csdl.Variable, +class Beam: + """ + A beam discretized into num_nodes - 1 two-node Euler-Bernoulli elements + with 6 dofs per node (3 translations, 3 rotations). + + Element matrices are built in local coordinates (x along the element) and + rotated to global coordinates. The mesh, material and cross-section are + csdl Variables/constants, so everything is differentiable. + + Parameters + ---------- + name : str + Unique name, used as the key of the per-beam results in Frame. + mesh : csdl.Variable + Node coordinates, shape (num_nodes, 3). + E, G : float + Young's modulus and shear modulus. + density : float + Material density. + cs : CrossSection + Cross-section (CSTube, CSBox, ...) with per-element properties, + shape (num_nodes - 1,). + z : bool, optional + Set True for a beam along the global z axis, where the default + local-axis construction is singular. + """ + + def __init__(self, + name:str, + mesh:csdl.Variable, E:float, G:float, density:float, - cs:'af.cs', - z=False): - + cs:CrossSection, + z:bool = False): + self.name = name self.mesh = mesh self.E = E self.G = G self.density = density - self.cs = cs self.z = z + self.num_nodes = mesh.shape[0] self.num_elements = self.num_nodes - 1 + + if cs.area.shape != (self.num_elements,): + raise ValueError(f'the cross-section of beam {name!r} has properties of shape {cs.area.shape}, ' + f'expected (num_nodes - 1,) = ({self.num_elements},)') + self.loads = None self.extra_inertial_mass = None self.fixed_boundary_conditions: List[int] = [] self.pinned_boundary_conditions: List[int] = [] - # map the beam nodes to the global indices - self.map: List[int] = [] - # precompute lengths + + # element geometry and direction cosines self.lengths, self.ll, self.mm, self.nn, self.D = self._lengths(mesh) - # beam-specific functions + + # element matrices in local and global coordinates self.local_stiffness = self._local_stiffness_matrices() self.local_mass = self._local_mass_matrices() self.transforms = self._vectorized_transforms() self.transformed_stiffness = self._transform_stiffness_matrices() self.transformed_mass = self._transform_mass_matrices() - + # mass properties element_masses = self.cs.area * self.lengths * self.density self.mass = csdl.sum(element_masses) cg2 = (self.mesh[1:, :] + self.mesh[:-1, :]) / 2 element_masses_expanded = csdl.expand(element_masses, (self.num_elements, 3), action='i->ij') - rmvec = csdl.sum(cg2 * element_masses_expanded, axes=(0,)) - - self.rmvec = rmvec - self.cg = rmvec / self.mass + self.rmvec = csdl.sum(cg2 * element_masses_expanded, axes=(0,)) + self.cg = self.rmvec / self.mass - - def fix(self, node: int): - + def fix(self, node:int)->None: + """clamp a node (all 6 dofs)""" if node < 0 or node > self.num_nodes - 1: raise ValueError('fixed nodes must be between 0 and num_nodes - 1') if node not in self.fixed_boundary_conditions and node not in self.pinned_boundary_conditions: self.fixed_boundary_conditions.append(node) - - def pin(self, node: int): + def pin(self, node:int)->None: + """pin a node (the 3 translations; rotations stay free)""" if node < 0 or node > self.num_nodes - 1: raise ValueError('pinned nodes must be between 0 and num_nodes - 1') @@ -70,40 +104,45 @@ def pin(self, node: int): self.pinned_boundary_conditions.append(node) - def add_inertial_mass(self, - mass: csdl.Variable, - ): - self.extra_inertial_mass = mass + def add_inertial_mass(self, mass:csdl.Variable)->None: + """ + add point masses at the nodes, shape (num_nodes,); they are resolved + as inertial loads when the Frame has an acceleration + """ + if mass.shape != (self.num_nodes,): + raise ValueError('inertial mass must have shape (num_beam_nodes,)') + self.extra_inertial_mass = mass - def add_load(self, load: csdl.Variable): + def add_load(self, load:csdl.Variable)->None: + """set the nodal loads [Fx, Fy, Fz, Mx, My, Mz], shape (num_nodes, 6)""" if load.shape != (self.num_nodes, 6): raise ValueError('load must have shape (num_beam_nodes, 6)') - + self.loads = load - - def _lengths(self, mesh)->tuple[csdl.Variable, csdl.Variable, csdl.Variable, csdl.Variable, csdl.Variable]: - # Compute the squared differences + + def _lengths(self, mesh:csdl.Variable)->tuple: + """ + element lengths and direction cosines (ll, mm, nn) of the element axes, + plus D = sqrt(ll^2 + mm^2) used by the transforms + """ diffs = mesh[1:] - mesh[:-1] - # Sum the squared differences along the rows and take the square root lengths = csdl.norm(diffs, axes=(1,)) exl = csdl.expand(lengths, (self.num_elements, 3), action='i->ij') cp = diffs / exl - # precomps for transforms ll = cp[:, 0] mm = cp[:, 1] nn = cp[:, 2] D = (ll**2 + mm**2)**0.5 - return lengths, ll, mm, nn, D - - def _local_stiffness_matrices(self)->csdl.Variable: + def _local_stiffness_matrices(self)->csdl.Variable: + """Euler-Bernoulli element stiffness matrices, shape (num_elements, 12, 12)""" A = self.cs.area E, G = self.E, self.G Iz = self.cs.iz @@ -111,18 +150,13 @@ def _local_stiffness_matrices(self)->csdl.Variable: J = self.cs.ix L = self.lengths - # local_stiffness = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - diag = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - off_diag = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - - # pre-computations for speed AEL = A*E/L nAEL = -AEL GJL = G*J/L nGJL = -GJL - EIz = E*Iz - EIzL = EIz/L + # bending about local z (v, theta_z) + EIzL = E*Iz/L EIzL2 = EIzL/L EIzL3 = EIzL2/L EIzL312 = 12*EIzL3 @@ -130,10 +164,10 @@ def _local_stiffness_matrices(self)->csdl.Variable: EIzL26 = 6*EIzL2 nEIzL26 = -EIzL26 EIzL4 = 4*EIzL - EIzL2 = 2*EIzL + EIzL_2 = 2*EIzL - EIy = E*Iy - EIyL = EIy/L + # bending about local y (w, theta_y) + EIyL = E*Iy/L EIyL2 = EIyL/L EIyL3 = EIyL2/L EIyL26 = 6*EIyL2 @@ -141,80 +175,28 @@ def _local_stiffness_matrices(self)->csdl.Variable: EIyL312 = 12*EIyL3 nEIyL312 = -EIyL312 EIyL4 = 4*EIyL - EIyL2 = 2*EIyL - - diag = diag.set(csdl.slice[:, 0, 0], AEL) - diag = diag.set(csdl.slice[:, 1, 1], EIzL312) - diag = diag.set(csdl.slice[:, 2, 2], EIyL312) - diag = diag.set(csdl.slice[:, 3, 3], GJL) - diag = diag.set(csdl.slice[:, 4, 4], EIyL4) - diag = diag.set(csdl.slice[:, 5, 5], EIzL4) - diag = diag.set(csdl.slice[:, 6, 6], AEL) - diag = diag.set(csdl.slice[:, 7, 7], EIzL312) - diag = diag.set(csdl.slice[:, 8, 8], EIyL312) - diag = diag.set(csdl.slice[:, 9, 9], GJL) - diag = diag.set(csdl.slice[:, 10, 10], EIyL4) - diag = diag.set(csdl.slice[:, 11, 11], EIzL4) - - - off_diag = off_diag.set(csdl.slice[:, 1, 5], EIzL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 5, 1], EIzL26) - - off_diag = off_diag.set(csdl.slice[:, 2, 4], nEIyL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 4, 2], nEIyL26) - - off_diag = off_diag.set(csdl.slice[:, 0, 6], nAEL) - # local_stiffness = local_stiffness.set(csdl.slice[:, 6, 0], nAEL) - - off_diag = off_diag.set(csdl.slice[:, 1, 7], nEIzL312) - # local_stiffness = local_stiffness.set(csdl.slice[:, 7, 1], nEIzL312) - - off_diag = off_diag.set(csdl.slice[:, 1, 11], EIzL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 11, 1], EIzL26) - - off_diag = off_diag.set(csdl.slice[:, 2, 8], nEIyL312) - # local_stiffness = local_stiffness.set(csdl.slice[:, 8, 2], nEIyL312) - - off_diag = off_diag.set(csdl.slice[:, 2, 10], nEIyL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 10, 2], nEIyL26) + EIyL_2 = 2*EIyL - off_diag = off_diag.set(csdl.slice[:, 3, 9], nGJL) - # local_stiffness = local_stiffness.set(csdl.slice[:, 9, 3], nGJL) + # dof order per node: u, v, w, theta_x, theta_y, theta_z + diag = [(0, AEL), (1, EIzL312), (2, EIyL312), (3, GJL), (4, EIyL4), (5, EIzL4), + (6, AEL), (7, EIzL312), (8, EIyL312), (9, GJL), (10, EIyL4), (11, EIzL4)] - off_diag = off_diag.set(csdl.slice[:, 4, 8], EIyL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 8, 4], EIyL26) + # upper triangle; the lower triangle is mirrored + off_diag = [(1, 5, EIzL26), (2, 4, nEIyL26), (0, 6, nAEL), (1, 7, nEIzL312), + (1, 11, EIzL26), (2, 8, nEIyL312), (2, 10, nEIyL26), (3, 9, nGJL), + (4, 8, EIyL26), (4, 10, EIyL_2), (5, 7, nEIzL26), (5, 11, EIzL_2), + (7, 11, nEIzL26), (8, 10, EIyL26)] - off_diag = off_diag.set(csdl.slice[:, 4, 10], EIyL2) - # local_stiffness = local_stiffness.set(csdl.slice[:, 10, 4], EIyL2) + return self._symmetric_matrices(diag, off_diag) - off_diag = off_diag.set(csdl.slice[:, 5, 7], nEIzL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 7, 5], nEIzL26) - - off_diag = off_diag.set(csdl.slice[:, 5, 11], EIzL2) - # local_stiffness = local_stiffness.set(csdl.slice[:, 11, 5], EIzL2) - - off_diag = off_diag.set(csdl.slice[:, 7, 11], nEIzL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 11, 7], nEIzL26) - - off_diag = off_diag.set(csdl.slice[:, 8, 10], EIyL26) - # local_stiffness = local_stiffness.set(csdl.slice[:, 10, 8], EIyL26) - - - local_stiffness = diag + off_diag + csdl.einsum(off_diag, action='ijk->ikj') # symmetric - - - - return local_stiffness - def _local_mass_matrices(self)->csdl.Variable: - + """consistent element mass matrices, shape (num_elements, 12, 12)""" A = self.cs.area rho = self.density J = self.cs.ix L = self.lengths - # coefficients aa = L / 2 aa2 = aa**2 coef = rho * A * aa / 105 @@ -229,248 +211,103 @@ def _local_mass_matrices(self)->csdl.Variable: ncoef13aa = -coef13aa coef8aa2 = coef * 8 * aa2 ncoef6aa2 = -coef * 6 * aa2 + # torsional inertia uses the polar radius of gyration squared rx2 = J / A coef70rx2 = coef70 * rx2 ncoef35rx2 = ncoef35 * rx2 - # local_mass = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - mdiag = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - moff_diag = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - - mdiag = mdiag.set(csdl.slice[:, 0, 0], coef70) - - mdiag = mdiag.set(csdl.slice[:, [1,2,7,8], [1,2,7,8]], coef78.expand((self.num_elements, 4), action='i->ij')) - - # mdiag = mdiag.set(csdl.slice[:, 1, 1], coef78) - # mdiag = mdiag.set(csdl.slice[:, 2, 2], coef78) - # local_mass = local_mass.set(csdl.slice[:, 3, 3], coef78 * rx2) - mdiag = mdiag.set(csdl.slice[:, 3, 3], coef70rx2) + diag = [(0, coef70), ([1, 2, 7, 8], coef78), (3, coef70rx2), + ([4, 5, 10, 11], coef8aa2), (6, coef70), (9, coef70rx2)] - mdiag = mdiag.set(csdl.slice[:, [4,5,10,11], [4,5,10,11]], coef8aa2.expand((self.num_elements, 4), action='i->ij')) - # mdiag = mdiag.set(csdl.slice[:, 4, 4], coef8aa2) - # mdiag = mdiag.set(csdl.slice[:, 5, 5], coef8aa2) - mdiag = mdiag.set(csdl.slice[:, 6, 6], coef70) - # mdiag = mdiag.set(csdl.slice[:, 7, 7], coef78) - # mdiag = mdiag.set(csdl.slice[:, 8, 8], coef78) - mdiag = mdiag.set(csdl.slice[:, 9, 9], coef70rx2) - # mdiag = mdiag.set(csdl.slice[:, 10, 10], coef8aa2) - # mdiag = mdiag.set(csdl.slice[:, 11, 11], coef8aa2) + # upper triangle; the lower triangle is mirrored + off_diag = [(2, 4, ncoef22aa), (1, 5, coef22aa), (0, 6, coef35), (1, 7, coef27), + (5, 7, coef13aa), (2, 8, coef27), (4, 8, ncoef13aa), (3, 9, ncoef35rx2), + (2, 10, coef13aa), (4, 10, ncoef6aa2), (8, 10, coef22aa), (1, 11, ncoef13aa), + (5, 11, ncoef6aa2), (7, 11, ncoef22aa)] + return self._symmetric_matrices(diag, off_diag) - moff_diag = moff_diag.set(csdl.slice[:, 2, 4], ncoef22aa) - # local_mass = local_mass.set(csdl.slice[:, 4, 2], ncoef22aa) - moff_diag = moff_diag.set(csdl.slice[:, 1, 5], coef22aa) - # local_mass = local_mass.set(csdl.slice[:, 5, 1], coef22aa) - - moff_diag = moff_diag.set(csdl.slice[:, 0, 6], coef35) - # local_mass = local_mass.set(csdl.slice[:, 6, 0], coef35) - - moff_diag = moff_diag.set(csdl.slice[:, 1, 7], coef27) - # local_mass = local_mass.set(csdl.slice[:, 7, 1], coef27) - - moff_diag = moff_diag.set(csdl.slice[:, 5, 7], coef13aa) - # local_mass = local_mass.set(csdl.slice[:, 7, 5], coef13aa) - - moff_diag = moff_diag.set(csdl.slice[:, 2, 8], coef27) - # local_mass = local_mass.set(csdl.slice[:, 8, 2], coef27) - - moff_diag = moff_diag.set(csdl.slice[:, 4, 8], ncoef13aa) - # local_mass = local_mass.set(csdl.slice[:, 8, 4], ncoef13aa) - - moff_diag = moff_diag.set(csdl.slice[:, 3, 9], ncoef35rx2) - # local_mass = local_mass.set(csdl.slice[:, 9, 3], ncoef35rx2) - - moff_diag = moff_diag.set(csdl.slice[:, 2, 10], coef13aa) - # local_mass = local_mass.set(csdl.slice[:, 10, 2], coef13aa) - - moff_diag = moff_diag.set(csdl.slice[:, 4, 10], ncoef6aa2) - # local_mass = local_mass.set(csdl.slice[:, 10, 4], ncoef6aa2) - - moff_diag = moff_diag.set(csdl.slice[:, 8, 10], coef22aa) - # local_mass = local_mass.set(csdl.slice[:, 10, 8], coef22aa) - - moff_diag = moff_diag.set(csdl.slice[:, 1, 11], ncoef13aa) - # local_mass = local_mass.set(csdl.slice[:, 11, 1], ncoef13aa) - - moff_diag = moff_diag.set(csdl.slice[:, 5, 11], ncoef6aa2) - # local_mass = local_mass.set(csdl.slice[:, 11, 5], ncoef6aa2) - - moff_diag = moff_diag.set(csdl.slice[:, 7, 11], ncoef22aa) - # local_mass = local_mass.set(csdl.slice[:, 11, 7], ncoef22aa) - - local_mass = mdiag + moff_diag + csdl.einsum(moff_diag, action='ijk->ikj') # symmetric - - - return local_mass - - - def _transforms(self)->csdl.Variable: + def _symmetric_matrices(self, diag:list, off_diag:list)->csdl.Variable: """ - no longer used - use vectorized_transforms() instead + build symmetric (num_elements, 12, 12) matrices from per-element values + diag: (index or list of indices, value); off_diag: (row, col, value), upper triangle """ - T = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) - - block = csdl.Variable(value=np.zeros((self.num_elements, 3, 3))) - for i in range(self.num_elements): - ll = self.ll[i] - mm = self.mm[i] - nn = self.nn[i] - nmm = -mm # precomp for speed - D = self.D[i] - nmmD = nmm / D - llD = ll / D + n = self.num_elements - if self.z: - block = block.set(csdl.slice[i, 0, 2], 1) - block = block.set(csdl.slice[i, 1, 1], 1) - block = block.set(csdl.slice[i, 2, 0], -1) - else: - block = block.set(csdl.slice[i, 0, 0], ll) - block = block.set(csdl.slice[i, 0, 1], mm) - block = block.set(csdl.slice[i, 0, 2], nn) - block = block.set(csdl.slice[i, 1, 0], nmmD) - block = block.set(csdl.slice[i, 1, 1], llD) - block = block.set(csdl.slice[i, 2, 0], -nn * llD) - block = block.set(csdl.slice[i, 2, 1], nn * nmmD) - block = block.set(csdl.slice[i, 2, 2], D) - - T = T.set(csdl.slice[:, 0:3, 0:3], block) - T = T.set(csdl.slice[:, 3:6, 3:6], block) - T = T.set(csdl.slice[:, 6:9, 6:9], block) - T = T.set(csdl.slice[:, 9:12, 9:12], block) - - # self.transformations_bookshelf = T + diag_matrices = csdl.Variable(value=np.zeros((n, 12, 12))) + for index, value in diag: + if isinstance(index, list): + value = value.expand((n, len(index)), action='i->ij') + diag_matrices = diag_matrices.set(csdl.slice[:, index, index], value) - return T + upper = csdl.Variable(value=np.zeros((n, 12, 12))) + for row, col, value in off_diag: + upper = upper.set(csdl.slice[:, row, col], value) + + return diag_matrices + upper + csdl.einsum(upper, action='ijk->ikj') def _vectorized_transforms(self)->csdl.Variable: """ - a vectorized version of the transforms() method + global-to-local rotation matrices T, shape (num_elements, 12, 12): + the same 3x3 direction-cosine block on each of the 4 diagonal blocks """ - ll = self.ll - mm = self.mm - nn = self.nn - D = self.D - T = csdl.Variable(value=np.zeros((self.num_elements, 12, 12))) + n = self.num_elements if self.z: - zeros = csdl.Variable(value=np.zeros((self.num_elements,))) - ones = csdl.Variable(value=np.ones((self.num_elements,))) - lls_concat = zeros - mms_concat = zeros - nns_concat = ones - nmmDs_concat = zeros - llDs_concat = ones - nnllD_concant = -ones - nnnmmD_concant = zeros - Ds_concat = zeros + # element along global z: local x = global z + zeros = csdl.Variable(value=np.zeros((n,))) + ones = csdl.Variable(value=np.ones((n,))) + block = [[zeros, zeros, ones], + [zeros, ones, None], + [-ones, zeros, zeros]] else: - lls_concat = ll - mms_concat = mm - nns_concat = nn - nmmDs_concat = -mm / D - llDs_concat = ll / D - nnllD_concant = -nn * llDs_concat - nnnmmD_concant = nn * nmmDs_concat - Ds_concat = D - - T = T.set(csdl.slice[:, [0,3,6,9], [0,3,6,9]], lls_concat.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [0,3,6,9], [1,4,7,10]], mms_concat.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [0,3,6,9], [2,5,8,11]], nns_concat.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [1,4,7,10], [0,3,6,9]], nmmDs_concat.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [1,4,7,10], [1,4,7,10]], llDs_concat.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [2,5,8,11], [0,3,6,9]], nnllD_concant.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [2,5,8,11], [1,4,7,10]], nnnmmD_concant.expand((self.num_elements, 4), action='i->ij')) - T = T.set(csdl.slice[:, [2,5,8,11], [2,5,8,11]], Ds_concat.expand((self.num_elements, 4), action='i->ij')) - + ll, mm, nn, D = self.ll, self.mm, self.nn, self.D + nmmD = -mm / D + llD = ll / D + block = [[ll, mm, nn], + [nmmD, llD, None], + [-nn * llD, nn * nmmD, D]] + + T = csdl.Variable(value=np.zeros((n, 12, 12))) + for r in range(3): + for c in range(3): + if block[r][c] is not None: + # entry (r, c) of all 4 diagonal blocks + rows = [r, r + 3, r + 6, r + 9] + cols = [c, c + 3, c + 6, c + 9] + T = T.set(csdl.slice[:, rows, cols], block[r][c].expand((n, 4), action='i->ij')) + + # kept for backward compatibility self.transformations_bookshelf = T return T - def _transform_stiffness_matrices(self)->csdl.Variable: + def _transform(self, local_matrices:csdl.Variable)->csdl.Variable: + """rotate local element matrices to global coordinates: T^T K T""" transforms = self.transforms - local_stiffness_matrices = self.local_stiffness - - # transformed_stiffness_matrices = [] - # for i in range(self.num_elements): - # T = transforms[i] - # local_stiffness = local_stiffness_matrices[i, :, :] - # TKT = csdl.matmat(csdl.transpose(T), csdl.matmat(local_stiffness, T)) - # transformed_stiffness_matrices.append(TKT) - - # Shape: (num_elements, n, n) - T_transpose = csdl.einsum(transforms, action='ijk->ikj') - # Shape: (num_elements, n, n) - T_transpose_K = csdl.einsum(T_transpose, local_stiffness_matrices, action='ijk,ikl->ijl') - # Shape: (num_elements, n, n) - transformed_stiffness_matrices = csdl.einsum(T_transpose_K, transforms, action='ijk,ikl->ijl') - - - return transformed_stiffness_matrices - - - def _transform_mass_matrices(self)->csdl.Variable: - transforms = self.transforms - local_mass_matrices = self.local_mass - - # transformed_mass_matrices = [] - - # for i in range(self.num_elements): - # T = transforms[i] - # local_mass = local_mass_matrices[i, :, :] - # TMT = csdl.matmat(csdl.transpose(T), csdl.matmat(local_mass, T)) - # transformed_mass_matrices.append(TMT) - - # Shape: (num_elements, n, n) T_transpose = csdl.einsum(transforms, action='ijk->ikj') - # Shape: (num_elements, n, n) - T_transpose_M = csdl.einsum(T_transpose, local_mass_matrices, action='ijk,ikl->ijl') - # Shape: (num_elements, n, n) - transformed_mass_matrices = csdl.einsum(T_transpose_M, transforms, action='ijk,ikl->ijl') + T_transpose_K = csdl.einsum(T_transpose, local_matrices, action='ijk,ikl->ijl') + return csdl.einsum(T_transpose_K, transforms, action='ijk,ikl->ijl') - return transformed_mass_matrices - - def _recover_loads(self, U)->csdl.Variable: - - map = self.map - displacements = csdl.Variable(value=np.zeros((self.num_elements, 12))) - lsb = self.local_stiffness - tb = self.transforms - - for i in range(self.num_elements): - idxa, idxb = map[i], map[i+1] - displacements = displacements.set(csdl.slice[i, 0:6], U[idxa:idxa+6]) - displacements = displacements.set(csdl.slice[i, 6:12], U[idxb:idxb+6]) - - # Perform transformations - transformed_displacements = csdl.einsum(tb, displacements, action='ijk,ik->ij') - - # Compute loads - loads = csdl.einsum(lsb, transformed_displacements, action='ijk,ik->ij') - - return loads - - - # def _mass(self)->tuple[csdl.Variable, csdl.Variable]: - - # lengths = self.lengths - # rho = self.density - # area = self.cs.area + def _transform_stiffness_matrices(self)->csdl.Variable: + """element stiffness matrices in global coordinates""" + return self._transform(self.local_stiffness) - # element_masses = area * lengths * rho - # beam_mass = csdl.sum(element_masses) - # cg2 = (self.mesh[1:, :] + self.mesh[:-1, :]) / 2 + def _transform_mass_matrices(self)->csdl.Variable: + """element mass matrices in global coordinates""" + return self._transform(self.local_mass) - # rmvec = 0 - # for i in range(self.num_elements): - # cg = (self.mesh[i + 1, :] + self.mesh[i, :]) / 2 - # rmvec += cg * element_masses[i] - # return beam_mass, rmvec + def element_loads(self, element_displacements:csdl.Variable)->csdl.Variable: + """ + local element end loads K_local T u_e, shape (num_elements, 12), from the + global element displacements u_e = [u_a, u_b], shape (num_elements, 12) + """ + local_displacements = csdl.einsum(self.transforms, element_displacements, action='ijk,ik->ij') + return csdl.einsum(self.local_stiffness, local_displacements, action='ijk,ik->ij') diff --git a/aframe/core/cs.py b/aframe/core/cs.py index 4d661ac..bb4183a 100644 --- a/aframe/core/cs.py +++ b/aframe/core/cs.py @@ -1,190 +1,233 @@ -# import aframe as af +""" +Beam cross-sections. + +Every cross-section is a ``CrossSection``: it provides per-element section +properties as csdl Variables of shape (num_elements,) + + area : cross-sectional area + ix : torsion constant (polar moment for circular sections) + iy : second moment of area about the local y axis + iz : second moment of area about the local z axis + +and, if it has a stress model, ``stress(element_loads)``, which maps the +(num_elements, 12) local element end loads to a stress measure. +""" +from typing import Tuple import numpy as np import csdl_alpha as csdl -# from dataclasses import dataclass -# from typing import Optional +__all__ = ['CrossSection', 'CSTube', 'CSCircle', 'CSEllipse', 'CSBox', 'CSBoxMarius'] + + +class CrossSection: + """ + Base class of all cross-sections, also usable directly for a section with + known properties (it has no stress model). + + Subclasses compute their properties and pass them to ``__init__``; those + with a stress model override ``stress``. + + Parameters + ---------- + area, ix, iy, iz : csdl.Variable + Section properties, shape (num_elements,). + """ + + def __init__(self, area:csdl.Variable, ix:csdl.Variable, iy:csdl.Variable, iz:csdl.Variable): + + if not area.shape == ix.shape == iy.shape == iz.shape: + raise ValueError('section properties area, ix, iy and iz must have the same shape') + + self.area = area + self.ix = ix + self.iy = iy + self.iz = iz + + + @property + def num_elements(self)->int: + return self.area.shape[0] + + + @staticmethod + def internal_loads(element_loads:csdl.Variable)->Tuple[csdl.Variable, ...]: + """ + internal loads at the element midspan from the local element end loads + [F_a, M_a, F_b, M_b], shape (num_elements, 12) + + returns (N, V_y, V_z, T, M_y, M_z), each shape (num_elements,): axial + force (tension positive), shear forces, torque and bending moments. + The end loads act on the element, so the internal load is (end_b - end_a) / 2 + (the forces and torque are constant along an element, the moments linear). + """ + return tuple((element_loads[:, 6 + i] - element_loads[:, i]) / 2 for i in range(6)) + + + def stress(self, element_loads:csdl.Variable)->csdl.Variable: + raise NotImplementedError(f'{type(self).__name__} has no stress model') + + +class CSTube(CrossSection): + """ + Hollow circular tube. + + Parameters + ---------- + radius : csdl.Variable + Outer radius, shape (num_elements,). + thickness : csdl.Variable + Wall thickness, shape (num_elements,). + """ -class CSTube: - def __init__(self, - radius:csdl.Variable, - thickness:csdl.Variable - ): + def __init__(self, radius:csdl.Variable, thickness:csdl.Variable): - # check that radius and thickness have the same shape if radius.shape != thickness.shape: raise ValueError('tube radius and thickness must have the same shape') - + self.radius = radius self.thickness = thickness self.inner_radius = radius - thickness self.outer_radius = radius self.precomp = np.pi * (self.outer_radius**4 - self.inner_radius**4) - @property - def area(self)->csdl.Variable: - return np.pi * (self.outer_radius**2 - self.inner_radius**2) - - @property - def ix(self)->csdl.Variable: - return self.precomp / 2 - - @property - def iy(self)->csdl.Variable: - return self.precomp / 4 - - @property - def iz(self)->csdl.Variable: - return self.precomp / 4 - - - def stress(self, element_loads)->csdl.Variable: - - F_x1 = element_loads[:, 0] - # F_y1 = element_loads[:, 1] - # F_z1 = element_loads[:, 2] - M_x1 = element_loads[:, 3] - M_y1 = element_loads[:, 4] - M_z1 = element_loads[:, 5] - - F_x2 = element_loads[:, 6] - # F_y2 = element_loads[:, 7] - # F_z2 = element_loads[:, 8] - M_x2 = element_loads[:, 9] - M_y2 = element_loads[:, 10] - M_z2 = element_loads[:, 11] - - - # average the nodal loads - F_x = (F_x1 + F_x2) / 2 - # F_y = (F_y1 + F_y2) / 2 - # F_z = (F_z1 + F_z2) / 2 - M_x = (M_x1 + M_x2) / 2 - M_y = (M_y1 + M_y2) / 2 - M_z = (M_z1 + M_z2) / 2 - - axial_stress = F_x / self.area - shear_stress = M_x * self.radius / self.ix + super().__init__(area=np.pi * (self.outer_radius**2 - self.inner_radius**2), + ix=self.precomp / 2, + iy=self.precomp / 4, + iz=self.precomp / 4) + + + def stress(self, element_loads:csdl.Variable)->csdl.Variable: + """ + von Mises stress at the most stressed point of the outer fiber, + shape (num_elements,): |N| / A + M r / I combined with the torsional shear + """ + N, _, _, T, M_y, M_z = self.internal_loads(element_loads) + # eps keeps the absolute values/square roots differentiable at zero load eps = 1E-12 + axial_stress = (N**2 + eps) ** 0.5 / self.area + shear_stress = T * self.radius / self.ix + max_moment = (M_y**2 + M_z**2 + eps) ** 0.5 bending_stress = max_moment * self.radius / self.iy - tensile_stress = axial_stress + bending_stress + normal_stress = axial_stress + bending_stress - eps = 1E-12 - von_mises_stress = (tensile_stress**2 + 3*shear_stress**2 + eps) ** 0.5 + return (normal_stress**2 + 3*shear_stress**2 + eps) ** 0.5 - - return von_mises_stress - +class CSCircle(CrossSection): + """ + Solid circular section (no stress model). + Parameters + ---------- + radius : csdl.Variable + Radius, shape (num_elements,). + """ + def __init__(self, radius:csdl.Variable): -class CSCircle: - def __init__(self, - radius:csdl.Variable, - ): - self.radius = radius self.precomp = np.pi * self.radius**4 - self.area = self._area() - self.ix = self._ix() - self.iy = self._iy() - self.iz = self._iz() + super().__init__(area=np.pi * self.radius**2, + ix=(1 / 2) * self.precomp, + iy=(1 / 4) * self.precomp, + iz=(1 / 4) * self.precomp) - # @property - def _area(self)->csdl.Variable: - return np.pi * self.radius**2 - - # @property - def _ix(self)->csdl.Variable: - return (1 / 2) * self.precomp - - # @property - def _iy(self)->csdl.Variable: - return (1 / 4) * self.precomp - - # @property - def _iz(self)->csdl.Variable: - return (1 / 4) * self.precomp - - def stress(self, element_loads)->csdl.Variable: +class CSEllipse(CrossSection): + """ + Solid elliptical section (no stress model). - pass + Parameters + ---------- + semi_major_axis : csdl.Variable + Semi-axis along the local z direction, shape (num_elements,). + semi_minor_axis : csdl.Variable + Semi-axis along the local y direction, shape (num_elements,). + """ + def __init__(self, semi_major_axis:csdl.Variable, semi_minor_axis:csdl.Variable): + a = self.semi_major_axis = semi_major_axis + b = self.semi_minor_axis = semi_minor_axis + area = np.pi * a * b + # approximate torsion constant + beta = 1 / ((1 + (b / a)**2)**0.5) + ix = (np.pi / 2) * a * b**3 * beta + iy = np.pi / 4 * a * b**3 + iz = np.pi / 4 * a**3 * b -class CSEllipse: - def __init__(self, - semi_major_axis:csdl.Variable, - semi_minor_axis:csdl.Variable - ): - - self.semi_major_axis = semi_major_axis - self.semi_minor_axis = semi_minor_axis + super().__init__(area=area, ix=ix, iy=iy, iz=iz) - self.area = self._area() - self.ix = self._ix() - self.iy = self._iy() - self.iz = self._iz() +class CSBox(CrossSection): + """ + Thin-walled rectangular box (e.g. a wing box), with separate top/bottom + skin and web thicknesses. Use ``CSBox.from_properties`` to supply the + section properties instead of the thin-walled formulas. - def _area(self)->csdl.Variable: - return np.pi * self.semi_major_axis * self.semi_minor_axis - - - def _ix(self)->csdl.Variable: - beta = 1 / ((1 + (self.semi_minor_axis / self.semi_major_axis)**2)**0.5) - return (np.pi / 2) * self.semi_major_axis * self.semi_minor_axis**3 * beta - - - def _iy(self)->csdl.Variable: - return np.pi / 4 * self.semi_major_axis * self.semi_minor_axis**3 - - - def _iz(self)->csdl.Variable: - return np.pi / 4 * self.semi_major_axis**3 * self.semi_minor_axis - - - def stress(self, element_loads): + Parameters + ---------- + ttop, tbot : csdl.Variable + Top and bottom skin thicknesses, shape (num_elements,). + tweb : csdl.Variable + Web (side wall) thickness, shape (num_elements,). + height, width : csdl.Variable + Outer height (local z) and width (local y), shape (num_elements,). + """ - pass - - - - -class CSBox: - def __init__(self, + def __init__(self, ttop:csdl.Variable, tbot:csdl.Variable, tweb:csdl.Variable, height:csdl.Variable, - width:csdl.Variable - ): - - # check that ttop, tbot, tweb, height and width have the same shape - if ttop.shape != tbot.shape or ttop.shape != tweb.shape or ttop.shape != height.shape or ttop.shape != width.shape: + width:csdl.Variable): + + self._set_dimensions(ttop, tbot, tweb, height, width) + + self.neutral_axis = self._neutral_axis() + area = self._area() + iy = self._iy() + iz = self._iz() + # thin-walled approximation + super().__init__(area=area, ix=iy + iz, iy=iy, iz=iz) + + + @classmethod + def from_properties(cls, + ttop:csdl.Variable, + tbot:csdl.Variable, + tweb:csdl.Variable, + height:csdl.Variable, + width:csdl.Variable, + area:csdl.Variable, + ix:csdl.Variable, + iy:csdl.Variable, + iz:csdl.Variable)->'CSBox': + """a box with user-supplied section properties; the dimensions are used for stress recovery""" + box = cls.__new__(cls) + box._set_dimensions(ttop, tbot, tweb, height, width) + CrossSection.__init__(box, area, ix, iy, iz) + return box + + + def _set_dimensions(self, ttop, tbot, tweb, height, width): + if not ttop.shape == tbot.shape == tweb.shape == height.shape == width.shape: raise ValueError('box beam ttop, tbot, tweb, height and width must have the same shape') - + self.ttop = ttop self.tbot = tbot self.tweb = tweb self.height = height self.width = width - self.neutral_axis = self._neutral_axis() - self.area = self._area() - self.iy = self._iy() - self.iz = self._iz() - self.ix = self._ix() - # @property def _neutral_axis(self)->tuple: + """(y, z) offset of the neutral axis from the box center""" Atop = self.ttop * (self.width - 2 * self.tweb) Abot = self.tbot * (self.width - 2 * self.tweb) @@ -192,348 +235,125 @@ def _neutral_axis(self)->tuple: centroid_y = 0 return (centroid_y, centroid_z) - - # @property - def type(self)->str: - return 'box' - # @property + def _area(self)->csdl.Variable: w_i = self.width - 2 * self.tweb h_i = self.height - self.ttop - self.tbot return self.width * self.height - w_i * h_i - - # @property - def _ix(self)->csdl.Variable: - ix = self.iy + self.iz - return ix - - # Older version - # tcap = (self.ttop + self.tbot) / 2 - # numerator = 2 * self.tweb * tcap * (self.width - self.tweb)**2 * (self.height - tcap)**2 - # denominator = self.width * self.tweb + self.height * tcap - self.tweb**2 - tcap**2 - # return numerator / denominator - - # @property + + def _iy(self)->csdl.Variable: - neutral_axis = self.neutral_axis - cy_neutral = neutral_axis[0] - cz_neutral = neutral_axis[1] + """parallel-axis sum of the skins and webs about the neutral axis""" + cz_neutral = self.neutral_axis[1] - # top + # top skin area_top = self.ttop * self.width iy_top = self.ttop ** 3 * self.width / 12 - cz_top = self.height / 2 - self.ttop / 2 - d_top = cz_top - cz_neutral + d_top = self.height / 2 - self.ttop / 2 - cz_neutral iy_top_centroid = iy_top + area_top * d_top**2 - # bottom + # bottom skin area_bot = self.tbot * self.width iy_bot = self.tbot ** 3 * self.width / 12 - cz_bot = -self.height / 2 + self.tbot / 2 - d_bot = cz_bot - cz_neutral + d_bot = -self.height / 2 + self.tbot / 2 - cz_neutral iy_bot_centroid = iy_bot + area_bot * d_bot**2 - # front/ rear - area_front = area_rear = self.tweb * (self.height - self.ttop - self.tbot) - iy_front = iy_rear = (self.height - self.ttop - self.tbot) ** 3 * self.tweb / 12 - - d_rear = cz_neutral - d_front = cz_neutral + # front/rear webs (centered at z = 0) + area_web = self.tweb * (self.height - self.ttop - self.tbot) + iy_web = (self.height - self.ttop - self.tbot) ** 3 * self.tweb / 12 + iy_rear_centroid = iy_web + area_web * cz_neutral**2 + iy_front_centroid = iy_web + area_web * cz_neutral**2 - iy_rear_centroid = iy_rear + area_rear * d_rear**2 - iy_front_centroid = iy_front + area_front * d_front**2 + return iy_top_centroid + iy_bot_centroid + iy_rear_centroid + iy_front_centroid - iy_total = iy_top_centroid + iy_bot_centroid + iy_rear_centroid + iy_front_centroid - # Older version - # w_i = self.width - 2 * self.tweb - # h_i = self.height - self.ttop - self.tbot - # return (self.width * self.height**3 - w_i * h_i**3) / 12 - - return iy_total - - # @property def _iz(self)->csdl.Variable: - neutral_axis = self.neutral_axis - cy_neutral = neutral_axis[0] - cz_neutral = neutral_axis[1] + """parallel-axis sum of the skins and webs about the neutral axis""" + cy_neutral = self.neutral_axis[0] - # top / bottom + # top/bottom skins (centered at y = 0) area_top = self.ttop * self.width iz_top = self.ttop * self.width**3 / 12 - area_bot = self.tbot * self.width iz_bot = self.tbot * self.width**3 / 12 - d_top = cy_neutral - d_bot = cy_neutral - - iz_top_centroid = iz_top + area_top * d_top**2 - iz_bot_centroid = iz_bot + area_bot * d_bot**2 - - # front/ rear - area_front = area_rear = self.tweb * (self.height - self.ttop - self.tbot) - iz_front = iz_rear = (self.height - self.ttop - self.tbot) * self.tweb**3 / 12 - - cy_front = -self.width / 2 + self.tweb / 2 - cy_rear = self.width / 2 - self.tweb / 2 - - d_front = cy_front - cy_neutral - d_rear = cy_rear - cy_neutral - - iz_front_centroid = iz_front + area_front * d_front**2 - iz_rear_centroid = iz_rear + area_rear * d_rear**2 + iz_top_centroid = iz_top + area_top * cy_neutral**2 + iz_bot_centroid = iz_bot + area_bot * cy_neutral**2 - iz_total = iz_top_centroid + iz_bot_centroid + iz_front_centroid + iz_rear_centroid + # front/rear webs + area_web = self.tweb * (self.height - self.ttop - self.tbot) + iz_web = (self.height - self.ttop - self.tbot) * self.tweb**3 / 12 - return iz_total + d_front = -self.width / 2 + self.tweb / 2 - cy_neutral + d_rear = self.width / 2 - self.tweb / 2 - cy_neutral - # Older version - # w_i = self.width - 2 * self.tweb - # h_i = self.height - self.ttop - self.tbot - # return (self.width**3 * self.height - w_i**3 * h_i) / 12 + iz_front_centroid = iz_web + area_web * d_front**2 + iz_rear_centroid = iz_web + area_web * d_rear**2 + return iz_top_centroid + iz_bot_centroid + iz_front_centroid + iz_rear_centroid - def stress(self, element_loads)->csdl.Variable: + def stress(self, element_loads:csdl.Variable)->csdl.Variable: """ - 0-----------------1 - | | - | | - 4 | - | | - | | - 3-----------------2 - """ - - stress = csdl.Variable(value=np.zeros((element_loads.shape[0], 5))) - - F_x1 = element_loads[:, 0] - # F_y1 = element_loads[:, 1] - F_z1 = element_loads[:, 2] - M_x1 = element_loads[:, 3] - M_y1 = element_loads[:, 4] - M_z1 = element_loads[:, 5] - - F_x2 = element_loads[:, 6] - # F_y2 = element_loads[:, 7] - F_z2 = element_loads[:, 8] - M_x2 = element_loads[:, 9] - M_y2 = element_loads[:, 10] - M_z2 = element_loads[:, 11] + von Mises stress at 5 points of the section, shape (num_elements, 5) + 0-----------------1 + | | + 4 | + | | + 3-----------------2 - # average the nodal loads - F_x = (F_x1 - F_x2) / 2 - # F_y = (F_y1 - F_y2) / 2 - F_z = (F_z1 - F_z2) / 2 - M_x = (M_x1 - M_x2) / 2 - M_y = (M_y1 - M_y2) / 2 - M_z = (M_z1 - M_z2) / 2 + points 0-3 are the corners (axial + bending + torsion); point 4 is the + web mid-height, which adds the vertical shear from V_z + """ + N, _, V_z, T, M_y, M_z = self.internal_loads(element_loads) # the axial stress is common to all stress evaluation points - axial_stress = F_x / self.area - - - # compute the von-mises stress at point 0 - z = -self.width / 2 - y = self.height / 2 - p = (z**2 + y**2)**0.5 - p0_torsional_stress = M_x * p / self.ix - p0_bending_stress_y = M_y * y / self.iy - p0_bending_stress_z = M_z * z / self.iz - p0_axial_stress = axial_stress + p0_bending_stress_y + p0_bending_stress_z - p0__von_mises = ((p0_axial_stress)**2 + 3*(p0_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 0], p0__von_mises) - - # compute the von-mises stress at point 1 - z = self.width / 2 - y = self.height / 2 - p = (z**2 + y**2)**0.5 - p1_torsional_stress = M_x * p / self.ix - p1_bending_stress_y = M_y * y / self.iy - p1_bending_stress_z = M_z * z / self.iz - p1_axial_stress = axial_stress + p1_bending_stress_y + p1_bending_stress_z - p1_von_mises = ((p1_axial_stress)**2 + 3*(p1_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 1], p1_von_mises) - - # compute the von-mises stress at point 2 - z = self.width / 2 - y = -self.height / 2 - p = (z**2 + y**2)**0.5 - p2_torsional_stress = M_x * p / self.ix - p2_bending_stress_y = M_y * y / self.iy - p2_bending_stress_z = M_z * z / self.iz - p2_axial_stress = axial_stress + p2_bending_stress_y + p2_bending_stress_z - p2_von_mises = ((p2_axial_stress)**2 + 3*(p2_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 2], p2_von_mises) - - # compute the von-mises stress at point 3 - z = -self.width / 2 - y = -self.height / 2 - p = (z**2 + y**2)**0.5 - p3_torsional_stress = M_x * p / self.ix - p3_bending_stress_y = M_y * y / self.iy - p3_bending_stress_z = M_z * z / self.iz - p3_axial_stress = axial_stress + p3_bending_stress_y + p3_bending_stress_z - p3_von_mises = ((p3_axial_stress)**2 + 3*(p3_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 3], p3_von_mises) - - # compute the von-mises stress at point 4 - z = -self.width / 2 - y = 0 - p = (z**2 + y**2)**0.5 - # approx first moment of area (Q) at point 4 + axial_stress = N / self.area + + def von_mises(z, y, shear=None): + p = (z**2 + y**2)**0.5 + torsional_stress = T * p / self.ix + if shear is not None: + torsional_stress = torsional_stress + shear + normal_stress = axial_stress + M_y * y / self.iy + M_z * z / self.iz + # 1E-8 keeps the square root differentiable at zero stress + return (normal_stress**2 + 3*torsional_stress**2 + 1E-8)**0.5 + + corners = [(-self.width / 2, self.height / 2), + (self.width / 2, self.height / 2), + (self.width / 2, -self.height / 2), + (-self.width / 2, -self.height / 2)] + points = [von_mises(z, y) for z, y in corners] + + # web mid-height: add the vertical shear V_z Q / (I t), with an + # approximate first moment of area Q and both webs (t = 2 tweb) tcap = (self.ttop + self.tbot) / 2 Q = self.width * tcap * (self.height / 2) + 2 * (self.height / 2) * self.tweb * (self.height / 4) - p4_torsional_stress = M_x * p / self.ix - p4_shear_stress = F_z * Q / (self.iy * 2 * self.tweb + 1e-8) - p4_bending_stress_y = M_y * y / self.iy - p4_bending_stress_z = M_z * z / self.iz - p4_axial_stress = axial_stress + p4_bending_stress_y + p4_bending_stress_z - p4_von_mises = ((p4_axial_stress)**2 + 3*(p4_torsional_stress + p4_shear_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 4], p4_von_mises) - - - return stress + shear_stress = V_z * Q / (self.iy * 2 * self.tweb) + points.append(von_mises(-self.width / 2, 0, shear_stress)) - - def buckle(self, element_loads)->csdl.Variable: + return csdl.transpose(csdl.vstack(points)) - pass +class CSBoxMarius(CSBox): + """ + Box with user-supplied section properties. + Deprecated: use ``CSBox.from_properties``, which takes the same arguments. + """ - - - -class CSBoxMarius: - def __init__(self, - ttop: csdl.Variable, - tbot: csdl.Variable, - tweb: csdl.Variable, - height: csdl.Variable, - width: csdl.Variable, - area : csdl.Variable, - ix : csdl.Variable, - iy : csdl.Variable, - iz : csdl.Variable, - ): - - self.ttop = ttop - self.tbot = tbot - self.tweb = tweb - self.height = height - self.width = width - self.area = area - self.ix = ix - self.iy = iy - self.iz = iz - - def stress(self, element_loads)->csdl.Variable: - - """ - 0-----------------1 - | | - | | - 4 | - | | - | | - 3-----------------2 - """ - - stress = csdl.Variable(value=np.zeros((element_loads.shape[0], 5))) - - F_x1 = element_loads[:, 0] - # F_y1 = element_loads[:, 1] - F_z1 = element_loads[:, 2] - M_x1 = element_loads[:, 3] - M_y1 = element_loads[:, 4] - M_z1 = element_loads[:, 5] - - F_x2 = element_loads[:, 6] - # F_y2 = element_loads[:, 7] - F_z2 = element_loads[:, 8] - M_x2 = element_loads[:, 9] - M_y2 = element_loads[:, 10] - M_z2 = element_loads[:, 11] - - - # average the nodal loads - F_x = (F_x1 - F_x2) / 2 - # F_y = (F_y1 - F_y2) / 2 - F_z = (F_z1 - F_z2) / 2 - M_x = (M_x1 - M_x2) / 2 - M_y = (M_y1 - M_y2) / 2 - M_z = (M_z1 - M_z2) / 2 - - # print('M_x', M_x.value) - # print('M_y', M_y.value) - # print('M_z', M_z.value) - - # the axial stress is common to all stress evaluation points - axial_stress = F_x / self.area - - - # compute the von-mises stress at point 0 - z = -self.width / 2 - y = self.height / 2 - p = (z**2 + y**2)**0.5 - p0_torsional_stress = M_x * p / self.ix - p0_bending_stress_y = M_y * y / self.iy - p0_bending_stress_z = M_z * z / self.iz - p0_axial_stress = axial_stress + p0_bending_stress_y + p0_bending_stress_z - p0__von_mises = ((p0_axial_stress)**2 + 3*(p0_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 0], p0__von_mises) - - # compute the von-mises stress at point 1 - z = self.width / 2 - y = self.height / 2 - p = (z**2 + y**2)**0.5 - p1_torsional_stress = M_x * p / self.ix - p1_bending_stress_y = M_y * y / self.iy - p1_bending_stress_z = M_z * z / self.iz - p1_axial_stress = axial_stress + p1_bending_stress_y + p1_bending_stress_z - p1_von_mises = ((p1_axial_stress)**2 + 3*(p1_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 1], p1_von_mises) - - # compute the von-mises stress at point 2 - z = self.width / 2 - y = -self.height / 2 - p = (z**2 + y**2)**0.5 - p2_torsional_stress = M_x * p / self.ix - p2_bending_stress_y = M_y * y / self.iy - p2_bending_stress_z = M_z * z / self.iz - p2_axial_stress = axial_stress + p2_bending_stress_y + p2_bending_stress_z - p2_von_mises = ((p2_axial_stress)**2 + 3*(p2_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 2], p2_von_mises) - - # compute the von-mises stress at point 3 - z = -self.width / 2 - y = -self.height / 2 - p = (z**2 + y**2)**0.5 - p3_torsional_stress = M_x * p / self.ix - p3_bending_stress_y = M_y * y / self.iy - p3_bending_stress_z = M_z * z / self.iz - p3_axial_stress = axial_stress + p3_bending_stress_y + p3_bending_stress_z - p3_von_mises = ((p3_axial_stress)**2 + 3*(p3_torsional_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 3], p3_von_mises) - - # compute the von-mises stress at point 4 - z = -self.width / 2 - y = 0 - p = (z**2 + y**2)**0.5 - # approx first moment of area (Q) at point 4 - tcap = (self.ttop + self.tbot) / 2 - Q = self.width * tcap * (self.height / 2) + 2 * (self.height / 2) * self.tweb * (self.height / 4) - p4_torsional_stress = M_x * p / self.ix - p4_shear_stress = F_z * Q / (self.iy * 2 * self.tweb + 1e-8) - p4_bending_stress_y = M_y * y / self.iy - p4_bending_stress_z = M_z * z / self.iz - p4_axial_stress = axial_stress + p4_bending_stress_y + p4_bending_stress_z - p4_von_mises = ((p4_axial_stress)**2 + 3*(p4_torsional_stress + p4_shear_stress)**2 + 1E-8)**0.5 - stress = stress.set(csdl.slice[:, 4], p4_von_mises) - - - return stress \ No newline at end of file + def __init__(self, + ttop:csdl.Variable, + tbot:csdl.Variable, + tweb:csdl.Variable, + height:csdl.Variable, + width:csdl.Variable, + area:csdl.Variable, + ix:csdl.Variable, + iy:csdl.Variable, + iz:csdl.Variable): + + self._set_dimensions(ttop, tbot, tweb, height, width) + CrossSection.__init__(self, area, ix, iy, iz) diff --git a/aframe/core/frame.py b/aframe/core/frame.py index e1395b5..ffac39d 100644 --- a/aframe/core/frame.py +++ b/aframe/core/frame.py @@ -1,114 +1,154 @@ +"""Frame: assembles beams and joints into a global linear system and solves it.""" +from __future__ import annotations +from typing import TYPE_CHECKING, Dict, List, Optional, Tuple import numpy as np -import aframe as af -# import scipy.sparse as sp -# import scipy.sparse.linalg as spla import csdl_alpha as csdl -from typing import List, Dict + +if TYPE_CHECKING: + from aframe.core.beam import Beam + from aframe.core.joint import Joint + +__all__ = ['Frame'] + + +def _concatenate(variables:List[csdl.Variable])->csdl.Variable: + """csdl.concatenate needs at least two variables (a frame can have a single beam)""" + if len(variables) == 1: + return variables[0] + return csdl.concatenate(variables) + + +def _scatter_add(init:np.ndarray, + positions:np.ndarray, + values:List[csdl.Variable])->csdl.Variable: + """ + scatter the (flattened, concatenated) values into the flat positions of the + constant init: each position that receives entries is set to their sum, + the other positions keep init, and entries with position -1 are dropped + + csdl slices cannot contain repeated indices, so entries that share a + position are gathered by rank (1st, 2nd, ... entry on each position) and + summed in order, and every position is then written with a single set + """ + values = _concatenate([value.flatten() for value in values]) + keep = np.nonzero(positions >= 0)[0] + order = keep[np.argsort(positions[keep], kind='stable')] + unique, first, inverse = np.unique(positions[order], return_index=True, return_inverse=True) + rank = np.arange(order.size) - first[inverse] + + out = values[order[rank == 0].tolist()] + for r in range(1, rank.max() + 1): + at = inverse[rank == r].tolist() + out = out.set(csdl.slice[at], out[at] + values[order[rank == r].tolist()]) + + return csdl.Variable(value=init.ravel()).set(csdl.slice[unique.tolist()], out).reshape(init.shape) + class Frame: + """ + A linear static frame model built from beams and joints. + + Building the Frame numbers the frame nodes and assembles the global + stiffness and mass matrices and the load vector (with boundary conditions + applied); call ``solve()`` for the displacements and ``compute_stress()`` + for the stresses. The dof numbering is owned by the Frame, so a Beam can + be used in several Frames. + + Parameters + ---------- + beams : list of Beam + The beams (unique objects with unique names), with loads and boundary + conditions already added. + joints : list of Joint, optional + Rigid connections between beams of this frame. + acc : csdl.Variable, optional + Frame acceleration [ax, ay, az, alpha_x, alpha_y, alpha_z], shape (6,), + applied as inertial loads M @ acc on the structure and extra masses. + + Attributes + ---------- + K, M : csdl.Variable + Global stiffness and mass matrices, shape (dim, dim), dim = 6 * num. + F : csdl.Variable + Global load vector, shape (dim,). + U : csdl.Variable + Global displacement vector, set by ``solve()``. + displacement, rotation : dict of csdl.Variable + Per-beam nodal displacements/rotations, shape (num_nodes, 3), set by ``solve()``. + num, dim : int + Number of frame nodes and of global dofs. + bc_indices : np.ndarray + Global indices of the constrained dofs. + """ + def __init__(self, - beams:List['af.Beam'], - joints:List['af.Joint'] = [], - acc:csdl.Variable = None,): - + beams:List[Beam], + joints:Optional[List[Joint]] = None, + acc:Optional[csdl.Variable] = None): + if acc is not None and acc.shape != (6,): raise ValueError("acc must have shape (6,)") - - # check if beams list is empty + if not beams: raise ValueError("beams must be added to the frame") - # self.beams: List[af.Beam] = [] + if len(set(map(id, beams))) != len(beams): + raise ValueError("each beam can be added to a frame only once") + + if len({beam.name for beam in beams}) != len(beams): + raise ValueError("beam names must be unique within a frame") + self.beams = beams - # self.joints: List[dict] = [] - self.joints = joints + self.joints = [] if joints is None else joints self.acc = acc self.displacement: Dict[str, csdl.Variable] = {} self.rotation: Dict[str, csdl.Variable] = {} self.U = None - # helper function - self.dim, self.num = self._utils() + # global node number of every node of every beam + self._nodes: Dict[Beam, np.ndarray] = self._number_nodes() + self.num = len(np.unique(np.concatenate(list(self._nodes.values())))) + self.dim = self.num * 6 + self.bc_indices = self._bc_indices() - # create stiffness and mass matrices + # global matrices and loads, with the boundary conditions applied self.K, self.M = self._global_matrices() + self.F = self._global_loads() - # create the global loads vector - self.F = self._global_loads(self.M) - - # apply boundary conditions by zeroing the rows and columns - self.K, self.M, self.F = self._boundary_conditions(self.K, self.M, self.F) - - - - - # def add_beam(self, beam:'af.Beam'): - # self.beams.append(beam) - - - # def add_joint(self, - # members:list, - # nodes:List[int]): - - # self.joints.append({'members': members, 'nodes': nodes}) + def solve(self)->None: + """solve K U = F and extract the per-beam displacements and rotations""" + self.U = U = csdl.solve_linear(self.K, self.F) - # def add_acc(self, acc:csdl.Variable): + for beam in self.beams: + u = self._nodal_displacements(beam) + self.displacement[beam.name] = u[:, :3] + self.rotation[beam.name] = u[:, 3:] - # if acc.shape != (6,): - # raise ValueError("acc must have shape 6") - # if self.acc is None: - # self.acc = acc - # else: - # raise ValueError("acc is not None") - - - def _utils(self)->tuple[int, int]: + def compute_stress(self, beams:Optional[List[Beam]] = None)->Dict[str, csdl.Variable]: + """ + per-beam stresses from the cross-section stress models (call solve() first) - idx = 0 - for beam in self.beams: - beam.map = [] - # beam.map.extend(range(idx, idx + beam.num_nodes)) - beam.map = list(range(idx, idx + beam.num_nodes)) - idx += beam.num_nodes + beams : the beams to evaluate (default: all); every one needs a + cross-section with a stress model + """ + if self.U is None: + raise RuntimeError("call solve() before compute_stress()") - # re-assign joint nodes - for joint in self.joints: - members = joint.members #joint['members'] - nodes = joint.nodes #joint['nodes'] - index = members[0].map[nodes[0]] - - for i, member in enumerate(members): - if i != 0: - member.map[nodes[i]] = index - - # nodes = set() - # for beam in self.beams: - # for i in range(beam.num_nodes): - # nodes.add(beam.map[i]) - # a faster version of the above code - nodes = {node for beam in self.beams for node in beam.map[:beam.num_nodes]} - - # the global dimension is the number of unique nodes times - # the degrees of freedom per node - num = len(nodes) - dim = num * 6 - - helper = {node: i for i, node in enumerate(nodes)} + stress = {} + for beam in self.beams if beams is None else beams: + # element displacements [u_a, u_b], shape (num_elements, 12) + u = self._nodal_displacements(beam) + element_displacements = csdl.concatenate([u[:-1], u[1:]], axis=1) - for beam in self.beams: - map = beam.map - - for i in range(beam.num_nodes): - map[i] = helper[map[i]] * 6 + stress[beam.name] = beam.cs.stress(beam.element_loads(element_displacements)) - return dim, num - + return stress - def compute_mass_properties(self)->tuple[csdl.Variable, csdl.Variable]: - # mass properties + def compute_mass_properties(self)->Tuple[csdl.Variable, csdl.Variable]: + """center of gravity (3,) and total mass of the beams (extra inertial masses excluded)""" mass, rmvec = 0, 0 for beam in self.beams: mass += beam.mass @@ -116,201 +156,124 @@ def compute_mass_properties(self)->tuple[csdl.Variable, csdl.Variable]: cg = rmvec / mass return cg, mass - - def compute_stress(self)->dict[csdl.Variable]: - # calculate the elemental loads and stresses - stress = {} - for beam in self.beams: - # elemental loads - element_loads = beam._recover_loads(self.U) - # element_loads = csdl.vstack(element_loads) - # perform a stress recovery - beam_stress = beam.cs.stress(element_loads) + def node_dofs(self, beam:Beam)->np.ndarray: + """global dof indices of every node of a beam, shape (num_nodes, 6)""" + return self._nodes[beam][:, None] * 6 + np.arange(6) - stress[beam.name] = beam_stress - return stress - - def _displacements(self, U:csdl.Variable)->None: - """ - parse the global displacement vector - and assign the displacements to each beam - in the displacement dictionary - """ + def _element_dofs(self, beam:Beam)->np.ndarray: + """global dof indices of every element of a beam, shape (num_elements, 12)""" + dofs = self.node_dofs(beam) + return np.hstack([dofs[:-1], dofs[1:]]) - # find the displacements - for beam in self.beams: - # self.displacement[beam.name] = csdl.Variable(value=np.zeros((beam.num_nodes, 3))) - map = beam.map - - map_u_to_d_x, map_u_to_d_y, map_u_to_d_z = [], [], [] - map_u_to_r_x, map_u_to_r_y, map_u_to_r_z = [], [], [] - for i in range(beam.num_nodes): - idx = map[i] - map_u_to_d_x.append(idx) - map_u_to_d_y.append(idx + 1) - map_u_to_d_z.append(idx + 2) - map_u_to_r_x.append(idx + 3) - map_u_to_r_y.append(idx + 4) - map_u_to_r_z.append(idx + 5) - - reshaped_U = csdl.transpose(csdl.vstack([U[map_u_to_d_x], U[map_u_to_d_y], U[map_u_to_d_z]])) - self.displacement[beam.name] = reshaped_U - - reshaped_R = csdl.transpose(csdl.vstack([U[map_u_to_r_x], U[map_u_to_r_y], U[map_u_to_r_z]])) - self.rotation[beam.name] = reshaped_R - - return None - - - def _global_matrices(self)->tuple[csdl.Variable, csdl.Variable]: + + def _nodal_displacements(self, beam:Beam)->csdl.Variable: + """rows of U for the nodes of a beam, shape (num_nodes, 6)""" + return self.U[self.node_dofs(beam).ravel().tolist()].reshape((beam.num_nodes, 6)) + + + def _number_nodes(self)->Dict[Beam, np.ndarray]: """ - create the global stiffness/mass matrices + global node numbers: every beam node gets a provisional id, joined + nodes are merged with union-find (independent of the joint order) and + the merged nodes are numbered contiguously """ + start, total = {}, 0 + for beam in self.beams: + start[beam] = total + total += beam.num_nodes + + parent = list(range(total)) + + def find(i): + while parent[i] != i: + parent[i] = parent[parent[i]] + i = parent[i] + return i + + for joint in self.joints: + for member in joint.members: + if member not in start: + raise ValueError(f"joint member {member.name!r} is not a beam of this frame") + + # the joint's first member provides the merged node's id + root = find(start[joint.members[0]] + joint.nodes[0]) + for member, node in zip(joint.members[1:], joint.nodes[1:]): + parent[find(start[member] + node)] = root + + # number the merged nodes in set order, which matches the numbering + # of earlier versions (the layout of K and U is unchanged) + ids = [find(i) for i in range(total)] + number = {node: n for n, node in enumerate(set(ids))} - K = csdl.Variable(value=np.zeros((self.dim, self.dim))) - M = csdl.Variable(value=np.zeros((self.dim, self.dim))) + return {beam: np.array([number[i] for i in ids[start[beam]:start[beam] + beam.num_nodes]]) + for beam in self.beams} + + def _bc_indices(self)->np.ndarray: + """global indices of the constrained dofs (fixed: all 6, pinned: 3 translations)""" + indices = [np.empty(0, dtype=int)] for beam in self.beams: - transformed_stiffness_matrices = beam.transformed_stiffness - transformed_mass_matrices = beam.transformed_mass - # add the elemental stiffness/mass matrices to their locations in the - # global stiffness/mass matrix - map = beam.map - - for i in range(beam.num_elements): - # for i, idxa, idxb in csdl.frange(vals = (list(range(beam.num_elements)), map[:-1], map[1:])): - stiffness = transformed_stiffness_matrices[i] - mass_matrix = transformed_mass_matrices[i] - idxa, idxb = map[i], map[i+1] - - K = K.set(csdl.slice[idxa:idxa+6, idxa:idxa+6], K[idxa:idxa+6, idxa:idxa+6] + stiffness[:6, :6]) - K = K.set(csdl.slice[idxa:idxa+6, idxb:idxb+6], K[idxa:idxa+6, idxb:idxb+6] + stiffness[:6, 6:]) - K = K.set(csdl.slice[idxb:idxb+6, idxa:idxa+6], K[idxb:idxb+6, idxa:idxa+6] + stiffness[6:, :6]) - K = K.set(csdl.slice[idxb:idxb+6, idxb:idxb+6], K[idxb:idxb+6, idxb:idxb+6] + stiffness[6:, 6:]) - - M = M.set(csdl.slice[idxa:idxa+6, idxa:idxa+6], M[idxa:idxa+6, idxa:idxa+6] + mass_matrix[:6, :6]) - M = M.set(csdl.slice[idxa:idxa+6, idxb:idxb+6], M[idxa:idxa+6, idxb:idxb+6] + mass_matrix[:6, 6:]) - M = M.set(csdl.slice[idxb:idxb+6, idxa:idxa+6], M[idxb:idxb+6, idxa:idxa+6] + mass_matrix[6:, :6]) - M = M.set(csdl.slice[idxb:idxb+6, idxb:idxb+6], M[idxb:idxb+6, idxb:idxb+6] + mass_matrix[6:, 6:]) + dofs = self.node_dofs(beam) + indices += [dofs[node] for node in beam.fixed_boundary_conditions] + indices += [dofs[node, :3] for node in beam.pinned_boundary_conditions] - return K, M - + return np.unique(np.concatenate(indices)) - def _global_loads(self, - M:csdl.Variable)->csdl.Variable: + + def _global_matrices(self)->Tuple[csdl.Variable, csdl.Variable]: """ - assemble the global loads vector - by summing the elemental loads - and adding any inertial loads + assemble the global stiffness/mass matrices from the element matrices; + the rows/columns of constrained dofs are never written and their + diagonal is set to 1 """ + dim = self.dim + is_bc = np.isin(np.arange(dim), self.bc_indices) - # assemble the global loads vector - F = csdl.Variable(value=np.zeros((self.dim))) - for beam in self.beams: - loads = beam.loads # shape: (n, 6) - map = beam.map # shape: (n,) + # global (row, col) of every entry of every element matrix + dofs = np.vstack([self._element_dofs(beam) for beam in self.beams]) + rows = np.repeat(dofs, 12, axis=1).ravel() + cols = np.tile(dofs, (1, 12)).ravel() + positions = np.where(is_bc[rows] | is_bc[cols], -1, rows * dim + cols) - if loads is not None: - - for i in range(beam.num_nodes): - idx = map[i] - F = F.set(csdl.slice[idx:idx+6], F[idx:idx+6] + loads[i, :]) + init = np.diag(is_bc.astype(float)) + K = _scatter_add(init, positions, [beam.transformed_stiffness for beam in self.beams]) + M = _scatter_add(init, positions, [beam.transformed_mass for beam in self.beams]) - - # add any inertial loads - acc = self.acc - if acc is not None: - expanded_acc = csdl.expand(acc, (self.num, 6), action='i->ji').flatten() - primary_inertial_loads = csdl.matvec(M, expanded_acc) - F += primary_inertial_loads - - # added inertial masses are resolved as loads - for beam in self.beams: - # if the beam has extra inertial mass - if beam.extra_inertial_mass is not None: - extra_mass = beam.extra_inertial_mass - extra_inertial_loads = csdl.outer(extra_mass, acc) - map = beam.map - - for i in range(beam.num_nodes): - idx = map[i] - F = F.set(csdl.slice[idx:idx+6], F[idx:idx+6] + extra_inertial_loads[i, :]) + return K, M - return F - - def _boundary_conditions(self, - K:csdl.Variable, - M:csdl.Variable, - F:csdl.Variable)->tuple[csdl.Variable, csdl.Variable, csdl.Variable]: + def _global_loads(self)->csdl.Variable: """ - apply boundary conditions - by zeroing the rows and columns - of the global stiffness/mass matrices - and putting 1s in the diagonal + assemble the global load vector from the nodal loads and any inertial + loads; loads on constrained dofs are dropped """ - # apply boundary conditions - indices = [] - for beam in self.beams: - map = beam.map - - # the fixed boundary conditions - for node in beam.fixed_boundary_conditions: - idx = map[node] - for i in range(6): - indices.append(idx + i) - - # the pinned boundary conditions - for node in beam.pinned_boundary_conditions: - idx = map[node] - for i in range(3): - indices.append(idx + i) - indices = list(set(indices)) - # zero the row/column then put a 1 in the diagonal - K = K.set(csdl.slice[indices, :], 0) - K = K.set(csdl.slice[:, indices], 0) - K = K.set(csdl.slice[indices, indices], 1) - # zero the row/column then put a 1 in the diagonal - M = M.set(csdl.slice[indices, :], 0) - M = M.set(csdl.slice[:, indices], 0) - M = M.set(csdl.slice[indices, indices], 1) - # zero the corresponding load index as well - F = F.set(csdl.slice[indices], 0) - - return K, M, F - - - # def dynamic_residual(self, - # U:csdl.Variable, - # U_dot:csdl.Variable, - # U_dotdot:csdl.Variable, - # damp=False, - # alpha=1E-4, - # beta=1E-2)->csdl.Variable: - - # if damp: C = alpha * self.M + beta * self.K - # else: C = csdl.Variable(value=np.zeros((self.dim, self.dim))) - - # R = csdl.matvec(self.K, U) + csdl.matvec(C, U_dot) + csdl.matvec(self.M, U_dotdot) - self.F - # # self.residual = R - - # # find the displacements - # self._displacements(U) - - # return R - - - - def solve(self): - - # solve the system of equations - self.U = U = csdl.solve_linear(self.K, self.F) + zeros = np.zeros(self.dim) - # find the displacements - self._displacements(U) + def positions(dofs): + dofs = np.concatenate([d.ravel() for d in dofs]) + return np.where(np.isin(dofs, self.bc_indices), -1, dofs) + # nodal loads + loaded = [beam for beam in self.beams if beam.loads is not None] + if loaded: + F = _scatter_add(zeros, positions([self.node_dofs(b) for b in loaded]), [b.loads for b in loaded]) + else: + F = csdl.Variable(value=zeros) - return None \ No newline at end of file + acc = self.acc + if acc is not None: + # structural inertial loads M @ acc, element by element: m_e @ [acc, acc] + acc12 = csdl.concatenate([acc, acc]) + inertial = [csdl.einsum(b.transformed_mass, acc12, action='ijk,k->ij') for b in self.beams] + F = F + _scatter_add(zeros, positions([self._element_dofs(b) for b in self.beams]), inertial) + + # extra point masses are resolved as loads + massed = [beam for beam in self.beams if beam.extra_inertial_mass is not None] + if massed: + extra = [csdl.outer(b.extra_inertial_mass, acc) for b in massed] + F = F + _scatter_add(zeros, positions([self.node_dofs(b) for b in massed]), extra) + + return F diff --git a/aframe/core/joint.py b/aframe/core/joint.py index 812c830..cfa89f7 100644 --- a/aframe/core/joint.py +++ b/aframe/core/joint.py @@ -1,12 +1,36 @@ -import aframe as af -from typing import List +"""Rigid joints that connect beams at shared nodes.""" +from __future__ import annotations +from typing import TYPE_CHECKING, List + +if TYPE_CHECKING: + from aframe.core.beam import Beam + +__all__ = ['Joint'] class Joint: + """ + Rigidly connect beams by merging one node of each into a single frame node + (all 6 dofs are shared). + + Parameters + ---------- + members : list of Beam + The beams to connect. + nodes : list of int + The node index in each member that is connected, same length as members + (negative indices count from the end of the beam). + """ + + def __init__(self, members:List[Beam], nodes:List[int])->None: + + if len(members) != len(nodes): + raise ValueError('a joint needs one node index per member') - def __init__(self, - members: List[af.Beam], - nodes: List[int]) -> None: + for member, node in zip(members, nodes): + if not -member.num_nodes <= node < member.num_nodes: + raise ValueError(f'joint node {node} is out of range for beam {member.name!r} ' + f'with {member.num_nodes} nodes') self.members = members - self.nodes = nodes \ No newline at end of file + self.nodes = [int(node) % member.num_nodes for member, node in zip(members, nodes)] diff --git a/aframe/core/backward_euler.py b/aframe/core/old/backward_euler.py similarity index 100% rename from aframe/core/backward_euler.py rename to aframe/core/old/backward_euler.py diff --git a/aframe/core/sim.py b/aframe/core/old/sim.py similarity index 100% rename from aframe/core/sim.py rename to aframe/core/old/sim.py diff --git a/aframe/utils/__init__.py b/aframe/utils/__init__.py index e69de29..f7687aa 100644 --- a/aframe/utils/__init__.py +++ b/aframe/utils/__init__.py @@ -0,0 +1 @@ +"""Meshing, plotting and load/displacement transfer utilities.""" diff --git a/aframe/utils/aeroelastic_utils.py b/aframe/utils/aeroelastic_utils.py index 52156ed..137704f 100644 --- a/aframe/utils/aeroelastic_utils.py +++ b/aframe/utils/aeroelastic_utils.py @@ -1,82 +1,65 @@ +"""Transfer of nodal values between non-matching meshes (e.g. aerodynamic <-> structural).""" import numpy as np +__all__ = ['NodalMap'] class NodalMap: - def __init__(self, mesh_in: np.ndarray, mesh_out: np.ndarray, method='rbf'): + """ + Map nodal values from mesh_in onto mesh_out with normalized distance + weights (each output node's weights sum to 1). + + Parameters + ---------- + mesh_in : np.ndarray + Source node coordinates, shape (n, 3). + mesh_out : np.ndarray + Target node coordinates, shape (m, 3). + method : {'rbf', 'idw'} + Gaussian radial basis function or inverse distance weighting. + """ + + def __init__(self, mesh_in:np.ndarray, mesh_out:np.ndarray, method:str = 'rbf'): self.mesh_in = mesh_in self.mesh_out = mesh_out self.n, _ = mesh_in.shape self.m, _ = mesh_out.shape self.method = method + self._weights = None - def rbf_weighting(self, eps=1): - # Compute the pairwise distances between each target point and all source points - distances = np.linalg.norm(mesh_in[:, np.newaxis, :] - mesh_out[np.newaxis, :, :], axis=2) - - # Apply the radial basis function formula - # Gaussian kernel - weights = np.exp(-eps * distances**2) - # Thin-plate spline kernel - # weights = distances**4 * np.log(distances + 1e-6) - weights /= weights.sum(axis=0, keepdims=True) # Normalize the weights - - return weights + def _distances(self)->np.ndarray: + """pairwise distances between the source and target nodes, shape (n, m)""" + return np.linalg.norm(self.mesh_in[:, np.newaxis, :] - self.mesh_out[np.newaxis, :, :], axis=2) - def inverse_distance_weighting(self, power=2): - # Compute the pairwise distances between each target point and all source points - distances = np.linalg.norm(mesh_in[:, np.newaxis, :] - mesh_out[np.newaxis, :, :], axis=2) - - # Apply the inverse distance weighting formula - with np.errstate(divide='ignore'): # To handle division by zero - weights = 1.0 / distances**power - weights /= weights.sum(axis=0, keepdims=True) # Normalize the weights - + def rbf_weighting(self, eps:float = 1)->np.ndarray: + """Gaussian kernel weights exp(-eps d^2), shape (n, m)""" + weights = np.exp(-eps * self._distances()**2) + weights /= weights.sum(axis=0, keepdims=True) return weights - - - def evaluate(self, values): - - if self.method == 'rbf': - weights = self.rbf_weighting() - elif self.method == 'idw': - weights = self.inverse_distance_weighting() - else: - raise ValueError(f"Invalid method: {self.method}") - - return self.mesh_out + weights.T @ values - - - -if __name__ == '__main__': - import matplotlib.pyplot as plt - - n_in = 10 - mesh_in = np.zeros((n_in, 3)) - mesh_in[:, 0] = np.linspace(0, 10, n_in) - - n_out = 12 - mesh_out = np.zeros((n_out, 3)) - mesh_out[:, 0] = np.linspace(0, 10, n_out) - mesh_out[:, 1] = 0.2 - - - disp = np.zeros((n_in, 3)) - disp[:, 1] = np.linspace(0, 2, n_in) - def_mesh_in = mesh_in + disp + def inverse_distance_weighting(self, power:float = 2)->np.ndarray: + """inverse distance weights 1 / d^power, shape (n, m)""" + # a coincident node gives an infinite weight + with np.errstate(divide='ignore'): + weights = 1.0 / self._distances()**power + weights /= weights.sum(axis=0, keepdims=True) + return weights - nm = NodalMap(mesh_in, mesh_out, method='rbf') - ans = nm.evaluate(disp) - - plt.plot(mesh_in[:, 0], mesh_in[:, 1], label='mesh_in') - plt.scatter(mesh_in[:, 0], mesh_in[:, 1]) - plt.scatter(mesh_out[:, 0], mesh_out[:, 1]) - plt.plot(ans[:, 0], ans[:, 1], label='mapped_mesh') - plt.plot(def_mesh_in[:, 0], def_mesh_in[:, 1], label='def_mesh_in') - plt.scatter(ans[:, 0], ans[:, 1], color='red', s=70) - plt.show() \ No newline at end of file + def evaluate(self, values:np.ndarray)->np.ndarray: + """ + map values (n, k) defined on mesh_in onto mesh_out and return + mesh_out + mapped values (e.g. the displaced target mesh), shape (m, k) + """ + if self._weights is None: + if self.method == 'rbf': + self._weights = self.rbf_weighting() + elif self.method == 'idw': + self._weights = self.inverse_distance_weighting() + else: + raise ValueError(f"Invalid method: {self.method}") + + return self.mesh_out + self._weights.T @ values diff --git a/aframe/utils/meshing.py b/aframe/utils/meshing.py index c0c570d..235e6ec 100644 --- a/aframe/utils/meshing.py +++ b/aframe/utils/meshing.py @@ -1,42 +1,27 @@ +"""Mesh generation helpers.""" import numpy as np +__all__ = ['mesh_from_points_and_edges'] -def mesh_from_points_and_edges(points, edges, num_nodes): +def mesh_from_points_and_edges(points:np.ndarray, edges:np.ndarray, num_nodes:int)->np.ndarray: """ - Create a 3D linspace mesh for each edge. - - Parameters: - points (numpy array): Array of shape (num_points, 3) containing the coordinates of the points. - edges (numpy array): Array of shape (num_edges, 2) containing the point connectivity. - num_nodes (int): The number of nodes to generate along each edge. - - Returns: - numpy array: Array of shape (num_edges, num_nodes, 3) containing the mesh points for each edge. + Straight beam meshes along the edges of a point cloud. + + Parameters + ---------- + points : np.ndarray + Point coordinates, shape (num_points, 3). + edges : np.ndarray + Point index pairs (start, end), shape (num_edges, 2). + num_nodes : int + Number of evenly spaced nodes per edge (including both end points). + + Returns + ------- + np.ndarray + Node coordinates, shape (num_edges, num_nodes, 3). """ - # Initialize the output array - mesh_points = np.zeros((edges.shape[0], num_nodes, 3)) - - # Loop through each edge to create the mesh - for i, (start_idx, end_idx) in enumerate(edges): - start_point = points[start_idx] - end_point = points[end_idx] - - # Create linspace for each coordinate - for j in range(3): - mesh_points[i, :, j] = np.linspace(start_point[j], end_point[j], num=num_nodes) - - return mesh_points - - - - - -if __name__ == '__main__': - # Example usage: - points = np.array([[0, 0, 0], [1, 1, 1], [2, 0, 0], [1, -1, 1]]) - edges = np.array([[0, 1], [1, 2], [2, 3], [3, 0]]) - num_nodes = 5 - - mesh = mesh_from_points_and_edges(points, edges, num_nodes) - print(mesh) + points = np.asarray(points) + edges = np.asarray(edges) + return np.linspace(points[edges[:, 0]], points[edges[:, 1]], num=num_nodes, axis=1) diff --git a/aframe/utils/plot_matplotlib.py b/aframe/utils/plot_matplotlib.py index af34716..55e2981 100644 --- a/aframe/utils/plot_matplotlib.py +++ b/aframe/utils/plot_matplotlib.py @@ -1,131 +1,73 @@ +""" +Matplotlib helpers for 3D beam plots. + +``plot_box`` and ``plot_circle`` return per-element cross-section outlines as +vertex lists for ``mpl_toolkits.mplot3d.art3d.Poly3DCollection``; ``mesh`` is a +numpy array of node coordinates, shape (num_nodes, 3). Elements parallel to +the global z axis are not supported (their rotation axis is undefined). +""" import numpy as np - +__all__ = ['plot_mesh', 'rotation_matrix_from_axis_angle', 'plot_box', 'plot_circle'] def plot_mesh(ax, mesh, size, line_color, marker_color, edge_color): - ax.scatter(mesh[:,0], mesh[:,1], mesh[:,2], color=marker_color, edgecolor=edge_color, s=size, alpha=1, linewidth=0.5) - ax.plot(mesh[:,0], mesh[:,1], mesh[:,2], color=line_color, linewidth=1) - - + """draw the mesh nodes and the polyline through them on a 3D axis""" + ax.scatter(mesh[:, 0], mesh[:, 1], mesh[:, 2], color=marker_color, edgecolor=edge_color, s=size, alpha=1, linewidth=0.5) + ax.plot(mesh[:, 0], mesh[:, 1], mesh[:, 2], color=line_color, linewidth=1) def rotation_matrix_from_axis_angle(axis, angle): + """rotation matrix for a rotation of angle (rad) about the unit vector axis (Rodrigues)""" c = np.cos(angle) s = np.sin(angle) t = 1 - c x, y, z = axis - rotation_matrix = np.array([[t*x*x + c, t*x*y - z*s, t*x*z + y*s], - [t*x*y + z*s, t*y*y + c, t*y*z - x*s], - [t*x*z - y*s, t*y*z + x*s, t*z*z + c]]) - return rotation_matrix - - -def plot_box(mesh, width, height): - - n = len(mesh) - - v1 = np.array([-width / 2, height / 2, np.zeros((n - 1))]) - v2 = np.array([width / 2, height / 2, np.zeros((n - 1))]) - v3 = np.array([width / 2, -height / 2, np.zeros((n - 1))]) - v4 = np.array([-width / 2, -height / 2, np.zeros((n - 1))]) - - current_normal = np.array([0, 0, 1]) - - vertices = [] - for i in range(n - 1): - - target_normal = (mesh[i+1, :] - mesh[i, :]) / np.linalg.norm(mesh[i+1, :] - mesh[i, :]) - - rotation_axis = np.cross(current_normal, target_normal) + return np.array([[t*x*x + c, t*x*y - z*s, t*x*z + y*s], + [t*x*y + z*s, t*y*y + c, t*y*z - x*s], + [t*x*z - y*s, t*y*z + x*s, t*z*z + c]]) + + +def _element_frames(mesh): + """ + for each element: the rotation taking the global z axis onto the element + axis, and the element midpoint + """ + z_axis = np.array([0, 0, 1]) + for i in range(len(mesh) - 1): + axis_vector = mesh[i + 1, :] - mesh[i, :] + target_normal = axis_vector / np.linalg.norm(axis_vector) + + rotation_axis = np.cross(z_axis, target_normal) rotation_axis /= np.linalg.norm(rotation_axis) - dot_product = np.dot(current_normal, target_normal) - rotation_angle = np.arccos(dot_product) - rotation_matrix = rotation_matrix_from_axis_angle(rotation_axis, rotation_angle) + rotation_angle = np.arccos(np.dot(z_axis, target_normal)) - offset = mesh[i, :] + (mesh[i + 1, :] - mesh[i, :]) / 2 + yield rotation_matrix_from_axis_angle(rotation_axis, rotation_angle), mesh[i, :] + axis_vector / 2 - nv1 = np.dot(rotation_matrix, v1[:, i]) + offset # v1 - nv2 = np.dot(rotation_matrix, v2[:, i]) + offset # v2 - nv3 = np.dot(rotation_matrix, v3[:, i]) + offset # v3 - nv4 = np.dot(rotation_matrix, v4[:, i]) + offset # v4 - # format required for matplotlib plotting - x = [nv1[0], nv2[0], nv3[0], nv4[0]] - y = [nv1[1], nv2[1], nv3[1], nv4[1]] - z = [nv1[2], nv2[2], nv3[2], nv4[2]] - verts = [list(zip(x, y, z))] - vertices.append(verts) +def plot_box(mesh, width, height): + """rectangle outlines (width x height) at each element midpoint, normal to the element""" + vertices = [] + for i, (rotation_matrix, offset) in enumerate(_element_frames(mesh)): + corners = np.array([[-width[i] / 2, height[i] / 2, 0], + [width[i] / 2, height[i] / 2, 0], + [width[i] / 2, -height[i] / 2, 0], + [-width[i] / 2, -height[i] / 2, 0]]) + points = corners @ rotation_matrix.T + offset + vertices.append([list(map(tuple, points))]) return vertices - - - def plot_circle(mesh, radius, num_circle): - n = len(mesh) - + """circle outlines (num_circle points) at each element midpoint, normal to the element""" theta = np.linspace(0, 2 * np.pi, num_circle) - current_normal = np.array([0, 0, 1]) # assumes the circle starts in the x-y plane vertices = [] - for i in range(n - 1): - - target_normal = (mesh[i+1, :] - mesh[i, :]) / np.linalg.norm(mesh[i+1, :] - mesh[i, :]) - - rotation_axis = np.cross(current_normal, target_normal) - rotation_axis /= np.linalg.norm(rotation_axis) - dot_product = np.dot(current_normal, target_normal) - rotation_angle = np.arccos(dot_product) - rotation_matrix = rotation_matrix_from_axis_angle(rotation_axis, rotation_angle) - - offset = mesh[i, :] + (mesh[i + 1, :] - mesh[i, :]) / 2 - - x, y, z = [], [], [] - for j in range(num_circle): - coord = np.array([radius[i] * np.cos(theta[j]), radius[i] * np.sin(theta[j]), 0]) - new_coord = np.dot(rotation_matrix, coord) + offset - x.append(new_coord[0]) - y.append(new_coord[1]) - z.append(new_coord[2]) - - - verts = [list(zip(x, y, z))] - vertices.append(verts) + for i, (rotation_matrix, offset) in enumerate(_element_frames(mesh)): + # circle in the x-y plane, rotated onto the element + circle = np.column_stack([radius[i] * np.cos(theta), radius[i] * np.sin(theta), np.zeros(num_circle)]) + points = circle @ rotation_matrix.T + offset + vertices.append([list(map(tuple, points))]) return vertices - - - - - - - -if __name__ == '__main__': - from mpl_toolkits.mplot3d.art3d import Poly3DCollection, Line3DCollection - import matplotlib.pyplot as plt - - - num_nodes = 6 - wing_mesh = np.zeros((num_nodes, 3)) - wing_mesh[:, 1] = np.linspace(-20, 20, num_nodes) - wing_width = np.ones(num_nodes-1)*1 - wing_height = np.ones(num_nodes-1)*0.5 - wing_radius = np.ones(num_nodes-1)*1 - - # vertices = plot_box(wing_mesh, wing_width, wing_height) - vertices = plot_circle(wing_mesh, wing_radius, num_circle=20) - - - fig = plt.figure() - ax = fig.add_subplot(projection='3d') - # ax.view_init(elev=35, azim=-10) - ax.set_box_aspect((1, 4, 1)) - - for i in range(num_nodes-1): - ax.add_collection3d(Poly3DCollection(vertices[i], facecolors='cyan', linewidths=1, edgecolors='r', alpha=.20)) - - ax.plot(wing_mesh[:, 0], wing_mesh[:, 1], wing_mesh[:, 2]) - ax.scatter(wing_mesh[:, 0], wing_mesh[:, 1], wing_mesh[:, 2]) - plt.show() \ No newline at end of file diff --git a/aframe/utils/plot_pyvista.py b/aframe/utils/plot_pyvista.py index 144b593..e4505c9 100644 --- a/aframe/utils/plot_pyvista.py +++ b/aframe/utils/plot_pyvista.py @@ -1,38 +1,44 @@ +""" +PyVista plotting helpers for beam meshes. + +All functions draw into an existing ``pyvista.Plotter``; ``mesh`` is a numpy +array of node coordinates, shape (num_nodes, 3), and per-element data has +shape (num_nodes - 1,). Requires the optional ``plot`` dependencies. +""" import numpy as np import pyvista as pv import matplotlib as mpl +__all__ = ['plot_box', 'plot_cyl', 'plot_mesh', 'plot_points'] def _colorize(cell_data, cmap, color, n): - + """per-element colors: cell_data normalized onto cmap, or a single color""" if cell_data is not None: - top = cell_data - cell_data.min() - bot = cell_data.max() - cell_data.min() - n_cell_data = top / bot + n_cell_data = (cell_data - cell_data.min()) / (cell_data.max() - cell_data.min()) + return mpl.colormaps[cmap](n_cell_data) - colormap = mpl.colormaps[cmap] + return [color] * n - colors = colormap(n_cell_data) - else: - colors = [color] * n - return colors +def _polyline(mesh:np.ndarray)->pv.PolyData: + """PolyData through the mesh nodes with one 2-point cell [2, i, i + 1] per element""" + n = mesh.shape[0] + cells = np.column_stack([np.full(n - 1, 2), np.arange(n - 1), np.arange(1, n)]) + return pv.PolyData(mesh, cells) -def plot_box(plotter, - mesh, - height, - width, - cell_data=None, - cmap='viridis', - color='lightblue', - ): - - n = mesh.shape[0] +def plot_box(plotter, mesh, height, width, cell_data=None, cmap='viridis', color='lightblue'): + """ + draw a rectangular box per element + height, width : per-element box dimensions + cell_data : optional per-element values used for coloring + """ + n = mesh.shape[0] colors = _colorize(cell_data, cmap, color, n) + up = np.array([0, 0, 1]) for i in range(n - 1): start = mesh[i, :] end = mesh[i + 1, :] @@ -41,136 +47,79 @@ def plot_box(plotter, length = np.linalg.norm(direction) direction /= length - up = np.array([0, 0, 1]) + # rotate the z-aligned cube onto the element axis if np.allclose(direction, up): axis = up angle = 0 else: axis = np.cross(up, direction) angle = np.rad2deg(np.arccos(np.dot(up, direction))) - + midpoint = (start + end) / 2 box = pv.Cube(center=midpoint, x_length=width[i], y_length=height[i], z_length=length) - box.rotate_vector(vector=axis, angle=angle, point=midpoint, inplace=True) plotter.add_mesh(box, color=colors[i], show_edges=True) -def plot_cyl(plotter, - mesh, - radius, - cell_data=None, - cmap='viridis', - color='lightblue', - ): - - n = mesh.shape[0] +def plot_cyl(plotter, mesh, radius, cell_data=None, cmap='viridis', color='lightblue'): + """ + draw a cylinder per element + radius : per-element cylinder radius + cell_data : optional per-element values used for coloring + """ + n = mesh.shape[0] colors = _colorize(cell_data, cmap, color, n) for i in range(n - 1): start = mesh[i, :] end = mesh[i + 1, :] - cyl = pv.Cylinder(center=(start + end) / 2, - direction=end - start, - radius=radius[i], + cyl = pv.Cylinder(center=(start + end) / 2, + direction=end - start, + radius=radius[i], height=np.linalg.norm(end - start)) plotter.add_mesh(cyl, color=colors[i]) - -def plot_mesh(plotter, - mesh, - cell_data=None, - plot_mesh=True, +def plot_mesh(plotter, + mesh, + cell_data=None, + plot_mesh=True, cmap='viridis', line_width=20, render_lines_as_tubes=True, - color='red', - ): - - n = mesh.shape[0] - - nodes = mesh - - edges = np.zeros((n - 1, 2)).astype(int) - for i in range(n - 1): edges[i, :] = [i, i + 1] - - padding = np.empty(edges.shape[0], int) * 2 - padding[:] = 2 - edges_w_padding = np.vstack((padding, edges.T)).T - - mesh = pv.PolyData(nodes, edges_w_padding) + color='red'): + """ + draw the beam as a polyline, optionally colored by per-element cell_data + (plot_mesh is unused and kept for backward compatibility) + """ + polyline = _polyline(mesh) if cell_data is not None: # normalize the cell data - n_cell_data = (cell_data - cell_data.min()) / (cell_data.max() - cell_data.min()) - mesh.cell_data['cell_data'] = n_cell_data - plotter.add_mesh(mesh, - scalars='cell_data', - render_lines_as_tubes=render_lines_as_tubes, - style='wireframe', - line_width=line_width, - cmap=cmap, - show_scalar_bar=False, - ) + polyline.cell_data['cell_data'] = (cell_data - cell_data.min()) / (cell_data.max() - cell_data.min()) + plotter.add_mesh(polyline, + scalars='cell_data', + render_lines_as_tubes=render_lines_as_tubes, + style='wireframe', + line_width=line_width, + cmap=cmap, + show_scalar_bar=False) else: - plotter.add_mesh(mesh, - render_lines_as_tubes=render_lines_as_tubes, - style='wireframe', - line_width=line_width, - color=color, - show_scalar_bar=False, - ) - - - -def plot_points(plotter, - mesh, - color='red', - point_size=50, - render_points_as_spheres=True): - - n = mesh.shape[0] - nodes = mesh - edges = np.zeros((n - 1, 2)).astype(int) - for i in range(n - 1): edges[i, :] = [i, i + 1] - padding = np.empty(edges.shape[0], int) * 2 - padding[:] = 2 - edges_w_padding = np.vstack((padding, edges.T)).T - - mesh = pv.PolyData(nodes, edges_w_padding) - - plotter.add_points(mesh.points, color=color, - point_size=point_size, - render_points_as_spheres=render_points_as_spheres, - ) - - - - - - - -if __name__ == '__main__': - - n = 10 - mesh = np.zeros((n, 3)) - mesh[:, 0] = np.linspace(0, 1, n) - cell_data = np.linspace(0, 10, n - 1) - - plotter = pv.Plotter() - # plot_mesh(plotter, mesh, cell_data) - # cs_data = np.ones((n - 1)) * 0.2 - # plot_cyl(plotter, mesh, cell_data, cs_data) - - height = np.ones((n - 1)) * 0.2 - width = np.ones((n - 1)) * 0.2 - plot_box(plotter, mesh, height, width, cell_data) - - - - plotter.show() \ No newline at end of file + plotter.add_mesh(polyline, + render_lines_as_tubes=render_lines_as_tubes, + style='wireframe', + line_width=line_width, + color=color, + show_scalar_bar=False) + + +def plot_points(plotter, mesh, color='red', point_size=50, render_points_as_spheres=True): + """draw the mesh nodes as points""" + plotter.add_points(np.asarray(mesh, dtype=float), + color=color, + point_size=point_size, + render_points_as_spheres=render_points_as_spheres) diff --git a/docs/Makefile b/docs/Makefile deleted file mode 100644 index d4bb2cb..0000000 --- a/docs/Makefile +++ /dev/null @@ -1,20 +0,0 @@ -# Minimal makefile for Sphinx documentation -# - -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build -SOURCEDIR = . -BUILDDIR = _build - -# Put it first so that "make" without argument is like "make help". -help: - @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - -.PHONY: help Makefile - -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/README.md b/docs/README.md deleted file mode 100644 index fdd66f3..0000000 --- a/docs/README.md +++ /dev/null @@ -1,35 +0,0 @@ - -# Documentation - -If you are not interested in using this repository as a template but only want to use the documentation template, -you can just copy the `/docs` directory and the `.readthedocs.yaml` file into your package root. -However, make sure you have all the dependencies mentioned in the `setup.py` file installed before you build your -documentation. - -## Writing -Start by modifying the documentation pages by editing `.md` files in the `/src` directory. -Customize/add/remove pages from the template according to your package's requirements. - -For automatically generated API references, add docstrings to your modules, classes, functions, etc., and -then edit the list of directories containing files with docstrings intended for automatic API generation. -This can be done by editing the line `autoapi_dirs = ["../../lsdo_project_template/core"]` -in `conf.py` in the `/src` directory. - -Add Python files for examples and Jupyter notebooks for tutorials into the main project repository. -Filenames for examples should start with'ex_'. -Add your examples and tutorials to the toctrees in `examples.md` and `tutorials.md` respectively. - -## Building -Once you have all the source code written for your documentation, on the terminal/command line, run `make html`. -This will build all the html pages locally and you can verify if the documentation was built as intended by -opening the `docs/_build/html/welcome.html` on your browser. - -## Hosting -On your/lsdolab *Read the Docs* account, **import** your project **manually** from github repository, and link the `/docs` directory. -Make sure to edit `requirements.txt` with dependencies for *Read the Docs* to build the documentation exactly -as in your local build. -Optionally, edit the `.readthedocs.yml` in the project root directory for building with specific operating systems or versions of Python. -After you commit and push, *Read the Docs* will build your package on its servers and once its complete, -you will see your documentation online. -The default website address will be generated based on your *Read the Docs* project name as `https://.readthedocs.io/`. -You can also customize the URL on *Read the Docs*, if needed. diff --git a/docs/conf.py b/docs/conf.py deleted file mode 100644 index 3666b5f..0000000 --- a/docs/conf.py +++ /dev/null @@ -1,209 +0,0 @@ -# Configuration file for the Sphinx documentation builder. -# -# This file only contains a selection of the most common options. For a full -# list see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html - -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. - -# import os -# import sys -# sys.path.insert(0, os.path.abspath('../lsdo_project_template/core')) # for autodoc - -# -- Project information ----------------------------------------------------- - -project = 'aframe' -copyright = '2023, Nicholas Orndorff' -author = 'Nicholas Orndorff' -version = '0.1' -# release = 0.1.0rtc - - -# -- General configuration --------------------------------------------------- - -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. -extensions = [ - "sphinx_rtd_theme", - "autoapi.extension", - "numpydoc", - "sphinx_copybutton", # allows copying code embedded in the docs rendered from .md or .ipynb files - "myst_nb", # renders .md, .myst, .ipynb files - "sphinx.ext.viewcode", # adds the source code for classes and functions in auto generated api ref - #"sphinxcontrib.collections", # adds files from outside src and executes functions before Sphinx builds - "sphinxcontrib.bibtex", # for references and citations -] - -# sphinxcontrib.bibtex options -bibtex_bibfiles = ['src/references.bib'] - -myst_title_to_header = True -myst_enable_extensions = ["dollarmath", "amsmath", "tasklist"] -nb_execution_mode = 'off' - -# autodoc options -# autodoc_typehints = 'description' - -# autoapi options -autoapi_dirs = ["../aframe/core"] -autoapi_root = 'src/autoapi' -autoapi_type = 'python' -autoapi_file_patterns = ['*.py', '*.pyi'] -autoapi_options = [ 'members', 'undoc-members', 'private-members', 'show-inheritance', - 'show-module-summary', 'special-members', 'imported-members', ] -autoapi_add_toctree_entry = False -autoapi_member_order = 'groupwise' -autoapi_python_class_content = 'class' # 'both' or '__init' - -root_doc = 'index' - -# source_suffix = { -# '.rst': 'restructuredtext', -# '.md': 'myst-nb', -# '.myst': 'myst-nb', -# '.ipynb': 'myst-nb', -# } - -# source_parsers = {'.md': 'myst-nb', -# '.ipynb': 'myst-nb', -# } - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['README.md', '_build', 'Thumbs.db', '.DS_Store', 'src/welcome.md'] - - -# -- Options for HTML output ------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -html_theme = 'sphinx_rtd_theme' # other theme options: 'sphinx_book_theme', 'sphinx_rtd_theme', - # 'alabaster', 'classic', 'sphinxdoc', 'nature', 'bizstyle', ... - -# html_theme_options for sphinx_rtd_theme -html_theme_options = { - 'logo_only': False, - 'display_version': True, - 'prev_next_buttons_location': 'bottom', - 'style_external_links': False, - 'vcs_pageview_mode': '', - 'style_nav_header_background': '#2980B9', # other valid colors: 'white', ... - # toc options - 'collapse_navigation': False, # default: True - 'sticky_navigation': True, - 'navigation_depth': 4, - 'includehidden': True, - 'titles_only': True # default: False -} - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -# html_static_path = ['_static'] - - -import glob -# Function used by collections for converting .py files from examples -# to .md and writing those into `_temp/target/` directory before Sphinx builds -def py2md(config): - # root_dir needs a trailing slash (i.e. /root/dir/) - for ex in glob.iglob(config['target'] + '**/ex_*.py', recursive=True): - with open(ex) as f: - code = f.read() - no_line_breaks = ' '.join(code.splitlines()) - - if code[0:3] == "'''": - title, desc = split_first_string_between_quotes(no_line_breaks, "'") - elif code[0:3] == '"""': - title, desc = split_first_string_between_quotes(no_line_breaks, '"') - else: - raise SyntaxError('Docstring for title and description is not declared correctly') - - with open(ex[:-3]+'.md', 'w') as g: - g.write('# ' + title + '\n') - g.write(desc + '\n\n') - g.write('```python\n') - g.write(code) - g.write('\n```') - - return - -import re - -def split_first_string_between_quotes(code_string, quotes): - if quotes == "'": - check = re.search("'''(.+?)'''", code_string) - elif quotes == '"': - check = re.search('"""(.+?)"""', code_string) - - if check: - docstring = check.group(1) - out_strings = docstring.split(':', 1) - if len(out_strings)==2: - title, desc = out_strings[0].strip(), out_strings[1].strip() - else: - title, desc = out_strings[0].strip(), '' - - return title, desc - - else: - raise SyntaxError('Docstring for title and description is not declared correctly') - -# collections = { - -# # copy_tutorials collection copies the contents inside `/tutorials` -# # directory into `/src/_temp/tutorials` -# 'copy_tutorials': { -# 'driver': 'copy_folder', -# 'source': '../tutorials', # source relative to path of makefile, not wrt /src -# 'target': 'tutorials/', -# 'ignore': [], -# # 'active': True, # default: True. If False, this collection is ignored during doc build. -# # 'safe': True, # default: True. If True, any problem will raise an exception and stops the build. -# 'clean': True, # default: True. If False, no cleanup is done before collections get executed. -# 'final_clean': True, # default: True. If True, a final cleanup is done at the end of a Sphinx build. -# # 'tags': ['my_collection', 'dummy'], # List of tags, which trigger an activation of the collection. -# # Should be used together with active set to False, -# # otherwise the collection gets always executed. -# # Use -t tag option of sphinx-build command to trigger related collections. -# # e.g. : `sphinx-build -b html -t dummy . _build/html` -# }, - -# 'copy_examples': { -# 'driver': 'copy_folder', -# 'source': '../examples', # source relative to path of makefile, not wrt /src -# 'target': 'examples/', -# 'ignore': [], -# 'clean': True, # default: True. If False, no cleanup is done before collections get executed. -# 'final_clean': True, # default: True. If True, a final cleanup is done at the end of a Sphinx build. -# }, - -# # convert_examples collection converts all .py files to .md files recursively inside `_temp/examples` -# # directory and also extracts the docstrings from the .py files to generate title and descriptions -# # for those examples -# 'convert_examples': { -# 'driver': 'writer_function', # uses custom WriterFunctionDriver written by Anugrah -# 'from' : '_temp/examples/', # source relative to path of makefile, not wrt /src -# 'source': py2md, # custom function written above in `conf.py` -# 'target': 'examples/', # target was a file for original FunctionDriver, e.g., 'target': 'examples/temp.txt' -# # the original FunctionDriver was supposed to write only 1 file. -# 'clean': True, -# 'final_clean': True, -# # 'write_result': True, # this prevents original FunctionDriver from writing to the target file -# }, -# } - -# collections_target = 'src/_temp' # default : '_collections', the default storage location for all collections -# collections_clean = True # default : True, all configured target locations get wiped out at the beginning -# # can be overwritten for individual collection by setting value for the 'clean' key -# collections_final_clean = True # default : True, all collections start their clean-up routine after a Sphinx build is done -# # can be overwritten for individual collection by setting value for the 'final_clean' key \ No newline at end of file diff --git a/docs/index.md b/docs/index.md deleted file mode 100644 index 4511d84..0000000 --- a/docs/index.md +++ /dev/null @@ -1,2 +0,0 @@ -```{include} src/welcome.md -``` diff --git a/docs/make.bat b/docs/make.bat deleted file mode 100644 index 32bb245..0000000 --- a/docs/make.bat +++ /dev/null @@ -1,35 +0,0 @@ -@ECHO OFF - -pushd %~dp0 - -REM Command file for Sphinx documentation - -if "%SPHINXBUILD%" == "" ( - set SPHINXBUILD=sphinx-build -) -set SOURCEDIR=. -set BUILDDIR=_build - -%SPHINXBUILD% >NUL 2>NUL -if errorlevel 9009 ( - echo. - echo.The 'sphinx-build' command was not found. Make sure you have Sphinx - echo.installed, then set the SPHINXBUILD environment variable to point - echo.to the full path of the 'sphinx-build' executable. Alternatively you - echo.may add the Sphinx directory to PATH. - echo. - echo.If you don't have Sphinx installed, grab it from - echo.https://www.sphinx-doc.org/ - exit /b 1 -) - -if "%1" == "" goto help - -%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% -goto end - -:help -%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% - -:end -popd diff --git a/docs/make_docs.py b/docs/make_docs.py new file mode 100644 index 0000000..02d920a --- /dev/null +++ b/docs/make_docs.py @@ -0,0 +1,47 @@ +""" +Build the aframe API documentation with pdoc. + + pip install -e ".[plot,docs]" + python docs/make_docs.py # static site in ./site + python docs/make_docs.py -o # static site in + +The landing page is the ``aframe`` package page: the README followed by the +public API. ``aframe.utils`` (meshing, load transfer and plotting) gets its own pages. +""" +import argparse +from pathlib import Path + +import pdoc +import pdoc.render + +import aframe +from aframe.utils import plot_pyvista + +MODULES = ['aframe', 'aframe.utils'] +SOURCE_URL = 'https://github.com/LSDOlab/aframe/blob/main/aframe/' + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('-o', '--output-directory', default='site', type=Path) + output = parser.parse_args().output_directory + + # aframe loads its plotting helpers lazily on first use, but pdoc only + # documents attributes that already exist, so load them here + for name in aframe._PLOTTING: + setattr(aframe, name, getattr(plot_pyvista, name)) + + pdoc.render.configure(docformat='numpy', + edit_url_map={'aframe': SOURCE_URL}, + footer_text=f'aframe {aframe.__version__}') + pdoc.pdoc(*MODULES, output_directory=output) + + # with several modules pdoc writes a module list as index.html; open the + # package page (README + API) instead + (output / 'index.html').write_text('\n\n' + 'aframe documentation\n', encoding='utf-8') + print(f'documentation written to {output.resolve()}') + + +if __name__ == '__main__': + main() diff --git a/docs/src/api.md b/docs/src/api.md deleted file mode 100644 index e3d67cf..0000000 --- a/docs/src/api.md +++ /dev/null @@ -1,9 +0,0 @@ -# API reference -This section contains auto-generated API reference for the package. - -```{toctree} -:maxdepth: 1 - -autoapi/vector/index -autoapi/matrix/index -``` \ No newline at end of file diff --git a/docs/src/background.md b/docs/src/background.md deleted file mode 100644 index 7f4b963..0000000 --- a/docs/src/background.md +++ /dev/null @@ -1,19 +0,0 @@ ---- -title: Background ---- - -This page is intended to provide the reader with any theoretical -knowledge or other concepts that form the basis of your package. -This page can include equations, figures, flowcharts, etc. for a better understanding of the theory behind -the package along with any code snippets necessary to explain the software design. - -## Referencing using bib files - -You can add references in the `references.bib` file and cite them -in the page like this {cite:p}`perez2011python`. -You can also include a list of references cited at the end as shown below. - -## Bibliography - -```{bibliography} references.bib -``` \ No newline at end of file diff --git a/docs/src/custom_1.md b/docs/src/custom_1.md deleted file mode 100644 index 066c11f..0000000 --- a/docs/src/custom_1.md +++ /dev/null @@ -1,4 +0,0 @@ -# Custom feature 1 - -Edit this page if you need to add custom pages for your package's documentation. -Otherwise, remove `custom1` from the toctree in `welcome.md`. \ No newline at end of file diff --git a/docs/src/custom_2.md b/docs/src/custom_2.md deleted file mode 100644 index 5524746..0000000 --- a/docs/src/custom_2.md +++ /dev/null @@ -1,4 +0,0 @@ -# Custom feature 2 - -Edit this page if you need to add custom pages for your package's documentation. -Otherwise, remove `custom2` from the toctree in `welcome.md`. \ No newline at end of file diff --git a/docs/src/examples.md b/docs/src/examples.md deleted file mode 100644 index 62d52ad..0000000 --- a/docs/src/examples.md +++ /dev/null @@ -1,21 +0,0 @@ -# Examples - -Unlike tutorials, examples can also be generated from Python files (.py) in addition -to Jupyter notebooks (.ipynb), -and is more of a collection of run scripts for reference/benchmarking. -Examples may contain documentation in the form of comments. -However, outputs/visualization from running the script is excluded if you are using Python files. - -If no classification of examples is required, just remove the subpages for examples -and add the example files directly into the toctree of this main examples page. - -```{toctree} -:maxdepth: 2 -:caption: List of examples -:titlesonly: -:numbered: -:includehidden: - -examples/basic -examples/advanced -``` \ No newline at end of file diff --git a/docs/src/examples/advanced.md b/docs/src/examples/advanced.md deleted file mode 100644 index 6b30d3f..0000000 --- a/docs/src/examples/advanced.md +++ /dev/null @@ -1,16 +0,0 @@ -# Advanced examples - -These pages for each category of examples are optional -and are required only if you plan to classify your examples -into different classes such as basic, intermediate, advanced, etc. -or any other classification suitable for your package. -If no classification is required, just remove these pages -and add the example files directly into the toctree of the main -examples page. - -```{toctree} -:maxdepth: 1 - -../_temp/examples/advanced_examples/ex_3quartic_opt_modopt -../_temp/examples/advanced_examples/ex_5modularity_NewtonLagrange -``` \ No newline at end of file diff --git a/docs/src/examples/basic.md b/docs/src/examples/basic.md deleted file mode 100644 index ed5ff39..0000000 --- a/docs/src/examples/basic.md +++ /dev/null @@ -1,17 +0,0 @@ -# Basic examples - -These pages for each category of examples are optional -and are required only if you plan to classify your examples -into different classes such as basic, intermediate, advanced, etc. -or any other classification suitable for your package. -If no classification is required, just remove these pages -and add the example files directly into the toctree of the main -examples page. - -```{toctree} -:maxdepth: 1 - -../_temp/examples/basic_examples/ex_1quartic_opt_csdl -../_temp/examples/basic_examples/ex_2quartic_opt_modopt -../_temp/examples/basic_examples/ex_4simple_example -``` \ No newline at end of file diff --git a/docs/src/getting_started.md b/docs/src/getting_started.md deleted file mode 100644 index 3271325..0000000 --- a/docs/src/getting_started.md +++ /dev/null @@ -1,56 +0,0 @@ -# Getting started -This page provides instructions for installing aframe -and running a minimal example. - - -### Installation instructions for users -For direct installation with all dependencies, run on the terminal or command line -```sh -$ pip install git+https://github.com/LSDOlab/aframe -``` -If you want users to install a specific branch, run -```sh -$ pip install git+https://github.com/LSDOlab/aframe.git@branch -``` - -**Enabled by**: Copying the `setup.py` file, changing your repository name and version, -and adding all your dependencies into the list `install_requires`. - -### Installation instructions for developers -To install `aframe`, first clone the repository and install using pip. -On the terminal or command line, run -```sh -$ git clone https://github.com/LSDOlab/aframe -$ pip install -e ./aframe -``` -**Enabled by**: Copying the setup.py file, and changing your repository name and version. - -### Writing -Start by modifying the documentation pages by editing `.md` files in the `/src` directory. -Customize/add/remove pages from the template according to your package's requirements. - -For automatically generated API references, add docstrings to your modules, classes, functions, etc., and -then edit the list of directories containing files with docstrings intended for automatic API generation. -This can be done by editing the line `autoapi_dirs = ["../../lsdo_project_template/core"]` -in `conf.py` in the `/src` directory. - -Add Python files for examples and Jupyter notebooks for tutorials into the main project repository. -Filenames for examples should start with'ex_'. -Add your examples and tutorials to the toctrees in `examples.md` and `tutorials.md` respectively. - -### Building -Once you have all the source code written for your documentation, on the terminal/command line, run `make html`. -This will build all the html pages locally and you can verify if the documentation was built as intended by -opening the `docs/_build/html/welcome.html` on your browser. - -### Hosting -On your *Read the Docs* account, **import** your project **manually** from github repository, and link the `/docs` directory. -Make sure to edit `requirements.txt` with dependencies for *Read the Docs* to build the documentation exactly -as in your local build. -Optionally, edit the `.readthedocs.yml` in the project root directory for building with specific operating systems or versions of Python. -After you commit and push, *Read the Docs* will build your package on its servers and once its complete, -you will see your documentation online. -The default website address will be generated based on your *Read the Docs* project name as `https://.readthedocs.io/`. -You can also customize the URL on *Read the Docs*, if needed. - -## Setting up Testing diff --git a/docs/src/images/lsdolab.png b/docs/src/images/lsdolab.png deleted file mode 100644 index 1de5e23..0000000 Binary files a/docs/src/images/lsdolab.png and /dev/null differ diff --git a/docs/src/images/lsdolab_website.png b/docs/src/images/lsdolab_website.png deleted file mode 100644 index 0e94a7b..0000000 Binary files a/docs/src/images/lsdolab_website.png and /dev/null differ diff --git a/docs/src/images/walrus.png b/docs/src/images/walrus.png deleted file mode 100644 index 03bcf74..0000000 Binary files a/docs/src/images/walrus.png and /dev/null differ diff --git a/docs/src/references.bib b/docs/src/references.bib deleted file mode 100644 index 1dd2107..0000000 --- a/docs/src/references.bib +++ /dev/null @@ -1,17 +0,0 @@ -@article{perez2011python, - title = {Python: An ecosystem for scientific computing}, - author = {Perez, Fernando and Granger, Brian E and Hunter, John D}, - journal = {Computing in Science & Engineering}, - volume = {13}, - number = {2}, - pages = {13--21}, - year = {2011}, - publisher = {AIP Publishing} -} - -@book{1987:nelson, - author = {Edward Nelson}, - title = {Radically Elementary Probability Theory}, - publisher = {Princeton University Press}, - year = {1987} -} diff --git a/docs/src/tutorials.md b/docs/src/tutorials.md deleted file mode 100644 index a12787f..0000000 --- a/docs/src/tutorials.md +++ /dev/null @@ -1,25 +0,0 @@ -# Tutorials - -These tutorials are generated from Jupyter notebooks (.ipynb) and -walks the reader through Python scripts providing detailed -step-by-step instructions. -Each tutorial contains mix of code and text that shows the -functionality of your package. -Tutorials are intended for explaining the fundamental capabilities of the package -and they get progressively more complicated. -It is recommeded that the tutorials also include mathematical equations and outputs/visualization -from running the script for better understanding for the users. - -If no classification of tutorials is required, just remove the subpages for tutorials -and add the tutorial files directly into the toctree of this main tutorials page. - -```{toctree} -:maxdepth: 2 -:caption: List of tutorials -:titlesonly: -:numbered: 1 -:includehidden: - -tutorials/basic -tutorials/advanced -``` \ No newline at end of file diff --git a/docs/src/tutorials/advanced.md b/docs/src/tutorials/advanced.md deleted file mode 100644 index bb4b6e0..0000000 --- a/docs/src/tutorials/advanced.md +++ /dev/null @@ -1,15 +0,0 @@ -# Advanced tutorials - -These pages for each category of tutorials are optional -and are required only if you plan to classify your tutorials -into different classes such as basic, intermediate, advanced, etc. -or any other classification suitable for your package. -If no classification is required, just remove these pages -and add the tutorial files directly into the toctree of the main -tutorials page. - -```{toctree} -:maxdepth: 1 - -../_temp/tutorials/advanced_tutorials/modopt_tutorial -``` \ No newline at end of file diff --git a/docs/src/tutorials/basic.md b/docs/src/tutorials/basic.md deleted file mode 100644 index 73384ea..0000000 --- a/docs/src/tutorials/basic.md +++ /dev/null @@ -1,15 +0,0 @@ -# Basic tutorials - -These pages for each category of tutorials are optional -and are required only if you plan to classify your tutorials -into different classes such as basic, intermediate, advanced, etc. -or any other classification suitable for your package. -If no classification is required, just remove these pages -and add the tutorial files directly into the toctree of the main -tutorials page. - -```{toctree} -:maxdepth: 1 - -../_temp/tutorials/basic_tutorials/jupyter_tutorial -``` \ No newline at end of file diff --git a/docs/src/welcome.md b/docs/src/welcome.md deleted file mode 100644 index 0b418e4..0000000 --- a/docs/src/welcome.md +++ /dev/null @@ -1,35 +0,0 @@ -# welcome to the aframe linear beam solver docs! - -![alt text](/src/images/walrus.png "Title displayed") - -This page provides documentation for the aframe linear beam solver. - - - -# Cite us -```none -@article{darpa, - Author = {Nicholas Orndorff, Bingran Wang, Marius Ruh, Andrew Fletcher, John Hwang}, - Journal = {AIAA Aviation}, - Title = {Gradient-based sizing optimization of power-beaming-enabled aircraft}, - pages = {}, - year = {2023}, - issn = {}, - doi = {} - } -``` - - - -```{toctree} -:maxdepth: 1 -:hidden: - -src/getting_started -src/background -src/tutorials -src/custom_1 -src/custom_2 -src/examples -src/api -``` diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..3d18662 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,38 @@ +[build-system] +requires = ["setuptools>=77"] +build-backend = "setuptools.build_meta" + +[project] +name = "aframe" +dynamic = ["version"] +description = "A differentiable linear 3D beam/frame solver written in CSDL" +readme = "README.md" +license = "MIT" +license-files = ["LICENSE.txt"] +authors = [{ name = "Nicholas Orndorff", email = "norndorff@ucsd.edu" }] +requires-python = ">=3.9" +dependencies = [ + "numpy", + # not on PyPI: pip install git+https://github.com/LSDOlab/CSDL_alpha.git + "csdl_alpha", +] + +[project.optional-dependencies] +plot = ["pyvista", "matplotlib"] +dev = ["pytest"] +docs = ["pdoc>=14"] + +[project.urls] +Homepage = "https://github.com/LSDOlab/aframe" +Repository = "https://github.com/LSDOlab/aframe" +Documentation = "https://lsdolab.github.io/aframe/" + +[tool.setuptools.dynamic] +version = { attr = "aframe.__version__" } + +[tool.setuptools.packages.find] +include = ["aframe*"] +exclude = ["aframe.core.old*"] + +[tool.pytest.ini_options] +testpaths = ["tests"] diff --git a/setup.py b/setup.py deleted file mode 100644 index b737463..0000000 --- a/setup.py +++ /dev/null @@ -1,25 +0,0 @@ -from setuptools import setup, find_packages - -with open("README.md", "r") as fh: - long_description = fh.read() - -setup( - name='aframe', - version='0.1.0', - author='Nicholas Orndorff', - author_email='norndorff@ucsd.edu', - license='MIT', - # keywords='python project template repository package', - url='https://github.com/LSDOlab/aframe', - download_url='https://github.com/LSDOlab/aframe', - description='A linear beam solver written in CSDL', - long_description=long_description, - long_description_content_type='text/markdown', - packages=find_packages(), - python_requires='>=3.7', - platforms=['any'], - install_requires=[ - 'numpy', - 'pyvista', - ], -) diff --git a/tests/README.md b/tests/README.md deleted file mode 100644 index 053760d..0000000 --- a/tests/README.md +++ /dev/null @@ -1,51 +0,0 @@ -# Developer Guidelines - -## Pull Requests -Before contributing to the `main` branch, make sure the following requirements are met: -- [ ] All existing tests have passed -- [ ] No local merge conflicts -- [ ] Code is commented -- [ ] Added tests for new features - -Once you finish making changes on your branch, create a pull request. -To create the pull request, follow the steps: - -1. Pull from `main` branch -```sh -git pull # Get most up-to-update version -``` -2. Merge with main and check for conflicts -```sh -git merge main # merge with main locally on your branch to check for conflicts -``` -3. Run tests -```sh -pytest # standard testing -pytest --disable-warnings # tests without displaying warnings -pytest -rP # tests while displaying print statements -``` - -4. Push changes - -```sh -git push -``` - -5. Create pull request on GitHub with descriptions for changes. - - Fill out pull request template - - Assign reviewers (repo admin(s)?) - -## Pull Request Review -When a pull request is submitted, reviews should be done in a timely manner (it will be time-consuming to remember what the code does if the code takes a week to be reviewed) - -When reviewing a pull request, approve when: - - Requirements above are met - - Make sure code is commented cleanly - - GitHub actions tests pass - - The code runs locally on your computer (run cases to try and break their code) - -When rejecting a pull request, write a precise description of what needs to improved/fixed in the comment section. - -## Tests -For test driven development, create tests before code implementation. -Templates from `tests/template.py` can be used. Create tests in `tests` directory and write test functions with `test_` prefix in test files. diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..1fd3662 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,11 @@ +import pytest +import csdl_alpha as csdl + + +@pytest.fixture +def recorder(): + """an active inline csdl recorder for the duration of a test""" + rec = csdl.Recorder(inline=True) + rec.start() + yield rec + rec.stop() diff --git a/tests/data/reference.npz b/tests/data/reference.npz new file mode 100644 index 0000000..242b988 Binary files /dev/null and b/tests/data/reference.npz differ diff --git a/tests/generate_reference.py b/tests/generate_reference.py new file mode 100644 index 0000000..08750cd --- /dev/null +++ b/tests/generate_reference.py @@ -0,0 +1,26 @@ +""" +Regenerate the golden values in tests/data/reference.npz used by test_regression.py. + +Only run this after an intended change of results, and review the change: + python tests/generate_reference.py +""" +import os +import numpy as np +import csdl_alpha as csdl +from models import MODELS, results + +here = os.path.dirname(os.path.abspath(__file__)) + +if __name__ == '__main__': + data = {} + for name in MODELS: + rec = csdl.Recorder(inline=True) + rec.start() + for key, value in results(name).items(): + data[f'{name}/{key}'] = value + rec.stop() + + os.makedirs(os.path.join(here, 'data'), exist_ok=True) + path = os.path.join(here, 'data', 'reference.npz') + np.savez_compressed(path, **data) + print(f'saved {len(data)} arrays to {path}') diff --git a/tests/models.py b/tests/models.py new file mode 100644 index 0000000..77eb34c --- /dev/null +++ b/tests/models.py @@ -0,0 +1,156 @@ +""" +Test models shared by the regression tests and generate_reference.py. + +Each builder must be called inside an active csdl Recorder and returns +(frame, design_variables). +""" +import numpy as np +import csdl_alpha as csdl +import aframe as af + +E, G, RHO = 69e9, 26e9, 2700.0 + + +def var(value, name=None): + return csdl.Variable(value=np.asarray(value, dtype=float), name=name) + + +def line(p0, p1, n): + return np.linspace(np.asarray(p0, dtype=float), np.asarray(p1, dtype=float), n) + + +def joined(n=11): + """examples/two_joined_beams.py: two tube beams joined at their tips""" + beams, dvs = [], [] + for name, load in (('beam_1', 2000), ('beam_2', 1000)): + loads = np.zeros((n, 6)) + loads[:, 2] = load + r = var(np.full(n - 1, 0.5), f'{name}_r') + t = var(np.full(n - 1, 0.001), f'{name}_t') + beam = af.Beam(name, var(line([0, 0, 0], [20, 0, 0], n)), E, G, RHO, af.CSTube(r, t)) + beam.add_load(var(loads)) + beams.append(beam) + dvs += [r, t] + beams[0].fix(0) + return af.Frame(beams, joints=[af.Joint(beams, [n - 1, n - 1])]), dvs + + +def tower(n=6): + """ + 3 inclined tube legs (2 fixed, 1 pinned) meeting a z-aligned tube mast in a + 4-member joint, a box-section ring joining the leg mid-points (3-member + joints), nodal loads, gravity and extra point masses on the mast + """ + rng = np.random.default_rng(0) + apex = np.array([0.3, -0.2, 10.0]) + bases = [np.array([5 * np.cos(a), 5 * np.sin(a), 0.0]) for a in np.deg2rad([10, 130, 250])] + mid = (n - 1) // 2 + dvs, legs, ring = [], [], [] + + for i, base in enumerate(bases): + r = var(0.15 + 0.02 * rng.random(n - 1), f'leg{i}_r') + t = var(0.01 + 0.002 * rng.random(n - 1), f'leg{i}_t') + legs.append(af.Beam(f'leg{i}', var(line(base, apex, n), f'leg{i}_mesh'), E, G, RHO, af.CSTube(r, t))) + dvs += [r, t] + legs[0].fix(0) + legs[1].fix(0) + legs[2].pin(0) + dvs.append(legs[0].mesh) + + for i in range(3): + p0, p1 = legs[i].mesh.value[mid], legs[(i + 1) % 3].mesh.value[mid] + box = {k: var(v * (1 + 0.1 * rng.random(n - 1)), f'ring{i}_{k}') + for k, v in dict(ttop=0.004, tbot=0.004, tweb=0.003, height=0.2, width=0.15).items()} + beam = af.Beam(f'ring{i}', var(line(p0, p1, n)), E, G, RHO, af.CSBox(**box)) + loads = np.zeros((n, 6)) + loads[:, 1] = 300.0 + loads[:, 2] = -800.0 + beam.add_load(var(loads)) + ring.append(beam) + dvs += list(box.values()) + + r, t = var(np.full(n - 1, 0.12), 'mast_r'), var(np.full(n - 1, 0.008), 'mast_t') + mast = af.Beam('mast', var(line(apex, apex + [0, 0, 8.0], n)), E, G, RHO, af.CSTube(r, t), z=True) + loads = np.zeros((n, 6)) + loads[:, 0] = 500.0 + loads[:, 1] = -250.0 + loads[:, 5] = 40.0 + mast.add_load(var(loads)) + mast.add_inertial_mass(var(np.full(n, 3.0), 'mast_extra_mass')) + dvs += [r, t] + + joints = [af.Joint(legs + [mast], [n - 1, n - 1, n - 1, 0])] + joints += [af.Joint([legs[i], ring[i], ring[i - 1]], [mid, 0, n - 1]) for i in range(3)] + acc = var([0.5, 0, -9.81, 0, 0, 0], 'acc') + return af.Frame(legs + ring + [mast], joints=joints, acc=acc), dvs + + +def all_sections(n=9): + """every cross-section type in one 3D frame, with joints, gravity and extra masses""" + rng = np.random.default_rng(3) + circ = af.CSCircle(var(0.1 + 0.05 * rng.random(n - 1), 'circ_r')) + ell = af.CSEllipse(var(0.2 + 0.05 * rng.random(n - 1), 'ell_a'), var(0.1 + 0.02 * rng.random(n - 1), 'ell_b')) + tube = af.CSTube(var(0.2 + 0.05 * rng.random(n - 1), 'tube_r'), var(0.01 + 0.002 * rng.random(n - 1), 'tube_t')) + box = af.CSBox(var(np.full(n - 1, .004)), var(np.full(n - 1, .003)), var(np.full(n - 1, .002)), + var(np.full(n - 1, .2)), var(np.linspace(.3, .15, n - 1), 'box_width')) + given = af.CSBox.from_properties(box.ttop, box.tbot, box.tweb, box.height, box.width, + box.area, box.ix, box.iy, box.iz) + + b_circ = af.Beam('circ', var(line([0, 0, 0], [4, 1, 0.5], n)), E, G, RHO, circ) + b_ell = af.Beam('ell', var(line([4, 1, 0.5], [8, -1, 1.0], n)), E, G, RHO, ell) + b_tube = af.Beam('tube', var(line([8, -1, 1.0], [8.5, 3, 2], n)), E, G, RHO, tube) + b_box = af.Beam('box', var(line([4, 1, 0.5], [3, 5, 1.5], n), 'box_mesh'), E, G, RHO, box) + b_given = af.Beam('given', var(line([3, 5, 1.5], [8.5, 3, 2], n)), E, G, RHO, given) + beams = [b_circ, b_ell, b_tube, b_box, b_given] + + b_circ.fix(0) + b_tube.pin(n - 1) + b_given.fix(n - 1) + for beam in beams: + loads = np.zeros((n, 6)) + loads[:, 2] = -500 * rng.random(n) + loads[:, 3] = 20 + beam.add_load(var(loads)) + b_ell.add_inertial_mass(var(np.full(n, 2.0))) + b_box.add_inertial_mass(var(np.full(n, 1.5))) + + joints = [af.Joint([b_circ, b_ell, b_box], [-1, 0, 0]), + af.Joint([b_ell, b_tube], [-1, 0]), + af.Joint([b_box, b_given], [-1, 0]), + af.Joint([b_tube, b_given], [-1, -1])] + frame = af.Frame(beams, joints=joints, acc=var([0, 0, -9.81, 0.1, 0, 0], 'acc')) + return frame, [circ.radius, ell.semi_major_axis, tube.thickness, box.width, b_box.mesh, frame.acc] + + +MODELS = {'joined': joined, 'tower': tower, 'all_sections': all_sections} + + +def has_stress_model(beam): + return type(beam.cs).stress is not af.CrossSection.stress + + +def objective(frame): + """solve the frame; compliance plus scaled stresses, and the stresses""" + frame.solve() + stress = frame.compute_stress(beams=[b for b in frame.beams if has_stress_model(b)]) + obj = csdl.vdot(frame.F, frame.U) + for s in stress.values(): + obj = obj + 1e-6 * csdl.sum(s) + return obj, stress + + +def results(name): + """build, solve and differentiate a model (inside an active inline recorder)""" + frame, dvs = MODELS[name]() + obj, stress = objective(frame) + derivatives = csdl.derivative(obj, dvs) + + out = {'K': frame.K.value, 'M': frame.M.value, 'F': frame.F.value, 'U': frame.U.value, 'obj': obj.value} + for beam in frame.beams: + out[f'displacement_{beam.name}'] = frame.displacement[beam.name].value + out[f'rotation_{beam.name}'] = frame.rotation[beam.name].value + if beam.name in stress: + out[f'stress_{beam.name}'] = stress[beam.name].value + for i, dv in enumerate(dvs): + out[f'd_{i}'] = derivatives[dv].value + return out diff --git a/tests/templates.py b/tests/templates.py deleted file mode 100644 index b2febcb..0000000 --- a/tests/templates.py +++ /dev/null @@ -1,81 +0,0 @@ -import pytest -import numpy as np - - -''' -Test to make sure desired output is correct -''' -def test_VALUES_TEMPLATE(): - ''' - Test description: what are we testing? - ''' - - # Import class/function to test - from lsdo_project_template.directory.file import Class - object = Class() - - # Run test scenario - input_val = 3.0 - desired_val = 6.0 - actual_val = object.add_two_numbers( - input_val, - input_val - ) - - # Check to make sure values are correct - np.testing.assert_almost_equal( - actual_val, - desired_val, - decimal = 7, - ) - -''' -Test to make sure desired output is correct -''' -def test_EQUAL_TEMPLATE(): - ''' - Test description: what are we testing? - ''' - - # Import class/function to test - from lsdo_project_template.directory.file import Class - object = Class() - - # Run test scenario - input_val = 3.5 - desired_output = False - actual_output = object.check_is_integer( - input_val - ) - - # Check to make sure values are correct - assert actual_output == desired_output - - -''' -Test to make sure exceptions are raised -''' -def test_EXCEPTIONS_TEMPLATE(): - - ''' - Test description: what are we testing? - ''' - - # Import class/function to test - from lsdo_project_template.directory.file import Class - object = Class() - - # Check to make sure exceptions are raised - with pytest.raises(Exception) as exc_info: - - # Run test scenario - variable_name_that_does_not_exist = 'x' - object.get_variable_name( - variable_name_that_does_not_exist - ) - - # Make sure the correct errors are being raised - assert exc_info.type is KeyError - assert str(exc_info.value) == 'caddee variable not found' - - diff --git a/tests/test_analytic.py b/tests/test_analytic.py new file mode 100644 index 0000000..b9e65ac --- /dev/null +++ b/tests/test_analytic.py @@ -0,0 +1,135 @@ +"""Checks against closed-form Euler-Bernoulli cantilever solutions (exact at the nodes).""" +import numpy as np +import pytest +import aframe as af +from models import E, G, RHO, var + +L, N_EL = 10.0, 10 +R, T = 0.1, 0.01 +A = np.pi * (R**2 - (R - T)**2) +I = np.pi * (R**4 - (R - T)**4) / 4 +J = 2 * I +P = 1000.0 +X_MID = (np.arange(N_EL) + 0.5) * L / N_EL + + +def cantilever(direction=(1, 0, 0), tip_load=None, z=False, acc=None, tip_mass=None, cs=None): + """tube cantilever of length L, fixed at node 0, along direction""" + d = np.asarray(direction, dtype=float) + d /= np.linalg.norm(d) + mesh = np.outer(np.linspace(0, L, N_EL + 1), d) + if cs is None: + cs = af.CSTube(var(np.full(N_EL, R)), var(np.full(N_EL, T))) + + beam = af.Beam('cantilever', var(mesh), E, G, RHO, cs, z=z) + beam.fix(0) + if tip_load is not None: + loads = np.zeros((N_EL + 1, 6)) + loads[-1] = tip_load + beam.add_load(var(loads)) + if tip_mass is not None: + mass = np.zeros(N_EL + 1) + mass[-1] = tip_mass + beam.add_inertial_mass(var(mass)) + + frame = af.Frame([beam], acc=None if acc is None else var(acc)) + frame.solve() + return frame, beam + + +def tip(frame, beam): + return frame.displacement[beam.name].value[-1], frame.rotation[beam.name].value[-1] + + +def assert_close(actual, expected, rtol=1e-8): + expected = np.asarray(expected, dtype=float) + np.testing.assert_allclose(actual, expected, rtol=rtol, atol=rtol * np.max(np.abs(expected))) + + +@pytest.mark.parametrize('load, displacement, rotation', [ + ((P, 0, 0, 0, 0, 0), (P * L / (E * A), 0, 0), (0, 0, 0)), + ((0, P, 0, 0, 0, 0), (0, P * L**3 / (3 * E * I), 0), (0, 0, P * L**2 / (2 * E * I))), + ((0, 0, P, 0, 0, 0), (0, 0, P * L**3 / (3 * E * I)), (0, -P * L**2 / (2 * E * I), 0)), + ((0, 0, 0, P, 0, 0), (0, 0, 0), (P * L / (G * J), 0, 0)), +], ids=['axial', 'bending_y', 'bending_z', 'torsion']) +def test_tip_loads(recorder, load, displacement, rotation): + frame, beam = cantilever(tip_load=load) + u, theta = tip(frame, beam) + scale = max(np.max(np.abs(displacement)), np.max(np.abs(rotation))) + np.testing.assert_allclose(u, displacement, rtol=1e-8, atol=1e-8 * scale) + np.testing.assert_allclose(theta, rotation, rtol=1e-8, atol=1e-8 * scale) + + +def test_inclined_beam(recorder): + """a tube is axisymmetric, so an inclined cantilever bends along the load""" + d = np.array([1.0, 2.0, 0.5]) / np.linalg.norm([1.0, 2.0, 0.5]) + perpendicular = np.cross(d, [0, 0, 1]) + perpendicular /= np.linalg.norm(perpendicular) + + frame, beam = cantilever(direction=d, tip_load=(*(P * perpendicular), 0, 0, 0)) + assert_close(tip(frame, beam)[0], P * perpendicular * L**3 / (3 * E * I)) + + +def test_inclined_beam_axial(recorder): + d = np.array([1.0, 2.0, 0.5]) / np.linalg.norm([1.0, 2.0, 0.5]) + frame, beam = cantilever(direction=d, tip_load=(*(P * d), 0, 0, 0)) + assert_close(tip(frame, beam)[0], d * P * L / (E * A)) + + +def test_vertical_beam(recorder): + frame, beam = cantilever(direction=(0, 0, 1), z=True, tip_load=(P, 0, 0, 0, 0, 0)) + assert_close(tip(frame, beam)[0], (P * L**3 / (3 * E * I), 0, 0)) + + +def test_gravity_and_tip_mass(recorder): + """consistent mass: M @ acc is the exact load vector of the uniform self-weight""" + g, tip_mass = 9.81, 50.0 + frame, beam = cantilever(acc=(0, 0, -g, 0, 0, 0), tip_mass=tip_mass) + w = RHO * A * g + expected = -w * L**4 / (8 * E * I) - tip_mass * g * L**3 / (3 * E * I) + assert_close(tip(frame, beam)[0], (0, 0, expected)) + + +def test_mass_properties(recorder): + frame, beam = cantilever(direction=(1, 1, 0)) + cg, mass = frame.compute_mass_properties() + assert_close(mass.value, [RHO * A * L]) + assert_close(beam.mass.value, [RHO * A * L]) + assert_close(cg.value, np.array([1, 1, 0]) / np.sqrt(2) * L / 2) + + +@pytest.mark.parametrize('axial', [5000.0, -5000.0], ids=['tension', 'compression']) +def test_tube_stress_bending_and_axial(recorder, axial): + frame, beam = cantilever(tip_load=(axial, 0, P, 0, 0, 0)) + stress = frame.compute_stress()[beam.name].value + assert_close(stress, abs(axial) / A + P * (L - X_MID) * R / I) + + +def test_tube_stress_torsion(recorder): + frame, beam = cantilever(tip_load=(0, 0, 0, P, 0, 0)) + stress = frame.compute_stress()[beam.name].value + assert_close(stress, np.full(N_EL, np.sqrt(3) * P * R / J)) + + +TTOP, TWEB, HEIGHT, WIDTH = 0.004, 0.003, 0.2, 0.15 + + +def box_cantilever(): + """symmetric box cantilever with a tip load along z""" + cs = af.CSBox(ttop=var(np.full(N_EL, TTOP)), tbot=var(np.full(N_EL, TTOP)), tweb=var(np.full(N_EL, TWEB)), + height=var(np.full(N_EL, HEIGHT)), width=var(np.full(N_EL, WIDTH))) + frame, beam = cantilever(tip_load=(0, 0, P, 0, 0, 0), cs=cs) + return frame.compute_stress()[beam.name].value, cs.iy.value + + +def test_box_stress_corners(recorder): + stress, iy = box_cantilever() + assert stress.shape == (N_EL, 5) + for point in range(4): + assert_close(stress[:, point], P * (L - X_MID) * (HEIGHT / 2) / iy) + + +def test_box_stress_web_shear(recorder): + stress, iy = box_cantilever() + Q = WIDTH * TTOP * (HEIGHT / 2) + 2 * (HEIGHT / 2) * TWEB * (HEIGHT / 4) + assert_close(stress[:, 4], np.sqrt(3) * P * Q / (iy * 2 * TWEB)) diff --git a/tests/test_frame.py b/tests/test_frame.py new file mode 100644 index 0000000..81d349f --- /dev/null +++ b/tests/test_frame.py @@ -0,0 +1,181 @@ +"""Frame assembly, dof numbering, validation and the cross-section contract.""" +import numpy as np +import pytest +import csdl_alpha as csdl +import aframe as af +from aframe.core.frame import _scatter_add +from models import E, G, RHO, var, line + +N = 5 + + +def tube(n=N, r=0.1, t=0.01): + return af.CSTube(var(np.full(n - 1, r)), var(np.full(n - 1, t))) + + +def beam(name, p0, p1, n=N, load=None, cs=None): + b = af.Beam(name, var(line(p0, p1, n)), E, G, RHO, tube(n) if cs is None else cs) + if load is not None: + loads = np.zeros((n, 6)) + loads[:, 2] = load + b.add_load(var(loads)) + return b + + +def star(): + """three beams meeting at (4, 0, 0); b2's first node is merged by one joint + and is the first member of the other""" + b1 = beam('b1', [0, 0, 0], [4, 0, 0], load=10.0) + b2 = beam('b2', [4, 0, 0], [4, 3, 0], load=20.0) + b3 = beam('b3', [4, 0, 0], [4, 0, 3], load=30.0) + b1.fix(0) + return b1, b2, b3 + + +def displacements(frame): + return {name: value.value.copy() for name, value in frame.displacement.items()} + + +def test_joint_order_does_not_matter(recorder): + results = [] + for order in (0, 1): + b1, b2, b3 = star() + joints = [af.Joint([b1, b2], [-1, 0]), af.Joint([b2, b3], [0, 0])] + frame = af.Frame([b1, b2, b3], joints=joints[::-1] if order else joints) + frame.solve() + assert frame.num == 3 * N - 2 + results.append(displacements(frame)) + + for name in results[0]: + np.testing.assert_array_equal(results[0][name], results[1][name]) + # the three beams share the joint node + joint = results[0]['b1'][-1] + np.testing.assert_array_equal(results[0]['b2'][0], joint) + np.testing.assert_array_equal(results[0]['b3'][0], joint) + + +def test_negative_joint_nodes(recorder): + b1, b2, _ = star() + joint = af.Joint([b1, b2], [-1, 0]) + assert joint.nodes == [N - 1, 0] + + +def test_beam_reuse_in_several_frames(recorder): + b1, b2, b3 = star() + joints = [af.Joint([b1, b2], [-1, 0]), af.Joint([b2, b3], [0, 0])] + frame_a = af.Frame([b1, b2, b3], joints=joints) + frame_b = af.Frame([b1]) # b1 alone, numbered differently + frame_a.solve() + frame_b.solve() + stress_a = frame_a.compute_stress() + + frame_c = af.Frame([b1, b2, b3], joints=joints) # reference: a fresh copy of frame_a + frame_c.solve() + stress_c = frame_c.compute_stress() + + for name, value in displacements(frame_c).items(): + np.testing.assert_array_equal(frame_a.displacement[name].value, value) + np.testing.assert_array_equal(stress_a[name].value, stress_c[name].value) + assert not np.allclose(frame_b.displacement['b1'].value, frame_a.displacement['b1'].value) + + +def test_node_dofs(recorder): + b1, b2, b3 = star() + frame = af.Frame([b1, b2, b3], joints=[af.Joint([b1, b2], [-1, 0]), af.Joint([b2, b3], [0, 0])]) + dofs = frame.node_dofs(b2) + assert dofs.shape == (N, 6) + np.testing.assert_array_equal(dofs[0], frame.node_dofs(b1)[-1]) + np.testing.assert_array_equal(dofs[0], frame.node_dofs(b3)[0]) + all_dofs = np.concatenate([frame.node_dofs(b).ravel() for b in (b1, b2, b3)]) + np.testing.assert_array_equal(np.unique(all_dofs), np.arange(frame.dim)) + + +@pytest.mark.parametrize('make', [ + lambda b1, b2, b3: af.Frame([]), + lambda b1, b2, b3: af.Frame([b1, b1]), + lambda b1, b2, b3: af.Frame([b1, beam('b1', [0, 0, 0], [0, 1, 0])]), + lambda b1, b2, b3: af.Frame([b1, b2], joints=[af.Joint([b1, b3], [-1, 0])]), + lambda b1, b2, b3: af.Frame([b1], acc=var(np.zeros(3))), + lambda b1, b2, b3: af.Joint([b1, b2], [0]), + lambda b1, b2, b3: af.Joint([b1, b2], [N, 0]), + lambda b1, b2, b3: af.Joint([b1, b2], [-N - 1, 0]), + lambda b1, b2, b3: af.Beam('b', var(line([0, 0, 0], [1, 0, 0], N)), E, G, RHO, tube(N + 1)), + lambda b1, b2, b3: b1.add_load(var(np.zeros((N, 3)))), + lambda b1, b2, b3: b1.add_inertial_mass(var(np.zeros(N - 1))), + lambda b1, b2, b3: b1.fix(N), + lambda b1, b2, b3: b1.pin(-1), + lambda b1, b2, b3: af.CSTube(var(np.ones(3)), var(np.ones(4))), + lambda b1, b2, b3: af.CSBox(*[var(np.ones(3))] * 4, var(np.ones(4))), + lambda b1, b2, b3: af.CrossSection(var(np.ones(3)), var(np.ones(3)), var(np.ones(3)), var(np.ones(4))), +], ids=['no_beams', 'duplicate_beam', 'duplicate_name', 'joint_member_not_in_frame', 'acc_shape', + 'joint_lengths', 'joint_node_high', 'joint_node_low', 'cs_shape', 'load_shape', + 'inertial_mass_shape', 'fix_range', 'pin_range', 'tube_shapes', 'box_shapes', 'property_shapes']) +def test_invalid_input(recorder, make): + with pytest.raises(ValueError): + make(*star()) + + +def test_compute_stress_requires_solve(recorder): + b1, _, _ = star() + with pytest.raises(RuntimeError): + af.Frame([b1]).compute_stress() + + +def test_sections_without_stress_model(recorder): + b1, _, _ = star() + circle = beam('circle', [4, 0, 0], [8, 0, 0], cs=af.CSCircle(var(np.full(N - 1, 0.05)))) + frame = af.Frame([b1, circle], joints=[af.Joint([b1, circle], [-1, 0])]) + frame.solve() + with pytest.raises(NotImplementedError): + frame.compute_stress() + assert list(frame.compute_stress(beams=[b1])) == ['b1'] + + +def test_generic_cross_section_matches_tube(recorder): + """a CrossSection with the tube's properties gives the same structural response""" + cs = tube() + b_tube = beam('tube', [0, 0, 0], [3, 1, 0], load=100.0, cs=cs) + generic = af.CrossSection(area=cs.area, ix=cs.ix, iy=cs.iy, iz=cs.iz) + b_generic = beam('generic', [0, 0, 0], [3, 1, 0], load=100.0, cs=generic) + assert generic.num_elements == N - 1 + + results = [] + for b in (b_tube, b_generic): + b.fix(0) + frame = af.Frame([b]) + frame.solve() + results.append(frame.displacement[b.name].value) + np.testing.assert_array_equal(results[0], results[1]) + + +def test_box_from_properties(recorder): + dims = [var(np.full(N - 1, v)) for v in (0.004, 0.003, 0.002, 0.2, 0.15)] + box = af.CSBox(*dims) + given = af.CSBox.from_properties(*dims, box.area, box.ix, box.iy, box.iz) + legacy = af.CSBoxMarius(*dims, box.area, box.ix, box.iy, box.iz) + assert isinstance(given, af.CSBox) and isinstance(legacy, af.CSBox) + + loads = var(np.random.default_rng(0).standard_normal((N - 1, 12)) * 1e3) + expected = box.stress(loads).value + np.testing.assert_array_equal(given.stress(loads).value, expected) + np.testing.assert_array_equal(legacy.stress(loads).value, expected) + + +def test_scatter_add(recorder): + """entries on a position are summed (like np.add.at), -1 positions dropped, + untouched positions keep init""" + rng = np.random.default_rng(1) + init = rng.standard_normal((4, 5)) + values = [rng.standard_normal((6, 2)), rng.standard_normal(7)] + positions = rng.integers(-1, init.size, size=19) + + flat = np.concatenate([v.ravel() for v in values]) + keep = positions >= 0 + sums = np.zeros(init.size) + np.add.at(sums, positions[keep], flat[keep]) + expected = init.ravel().copy() + touched = np.unique(positions[keep]) + expected[touched] = sums[touched] + + out = _scatter_add(init, positions, [var(v) for v in values]) + np.testing.assert_allclose(out.value, expected.reshape(init.shape), rtol=1e-15) diff --git a/tests/test_gradients.py b/tests/test_gradients.py new file mode 100644 index 0000000..5898d6f --- /dev/null +++ b/tests/test_gradients.py @@ -0,0 +1,34 @@ +"""Reverse-mode derivatives against central finite differences.""" +import numpy as np +import csdl_alpha as csdl +import models + + +def test_gradients_match_finite_differences(recorder): + frame, dvs = models.all_sections(n=5) + obj, _ = models.objective(frame) + derivatives = csdl.derivative(obj, dvs) + # snapshot before the perturbations below re-execute the graph + analytic_all = [derivatives[dv].value.ravel().copy() for dv in dvs] + rng = np.random.default_rng(0) + + for dv, analytic in zip(dvs, analytic_all): + base = dv.value.copy() + + for k in rng.choice(base.size, size=min(3, base.size), replace=False): + h = 1e-6 * max(1.0, abs(base.flat[k])) + values = [] + for sign in (1, -1): + perturbed = base.copy() + perturbed.flat[k] += sign * h + dv.value = perturbed + recorder.execute() + values.append(obj.value[0]) + dv.value = base + recorder.execute() + + fd = (values[0] - values[1]) / (2 * h) + tol = 1e-5 * abs(analytic[k]) + 1e-7 * np.max(np.abs(analytic)) + assert abs(fd - analytic[k]) <= tol, f'{dv.name}[{k}]: finite difference {fd}, derivative {analytic[k]}' + + recorder.execute() diff --git a/tests/test_jax.py b/tests/test_jax.py new file mode 100644 index 0000000..362567e --- /dev/null +++ b/tests/test_jax.py @@ -0,0 +1,29 @@ +"""The JAX backend reproduces the inline (NumPy) results.""" +import numpy as np +import pytest +import csdl_alpha as csdl +import models + +pytest.importorskip('jax') + + +def test_jax_matches_inline(): + rec = csdl.Recorder(inline=True) + rec.start() + frame, dvs = models.tower(n=4) + obj, _ = models.objective(frame) + derivatives = csdl.derivative(obj, dvs) + rec.stop() + + inline_U, inline_obj = frame.U.value.copy(), obj.value.copy() + inline_d = [derivatives[dv].value.copy() for dv in dvs] + + sim = csdl.experimental.JaxSimulator(rec, additional_inputs=dvs, additional_outputs=[obj, frame.U], gpu=False) + sim.run() + np.testing.assert_allclose(sim[frame.U], inline_U, rtol=1e-9, atol=1e-9 * np.max(np.abs(inline_U))) + np.testing.assert_allclose(sim[obj], inline_obj, rtol=1e-9) + + totals = sim.compute_totals() + for dv, expected in zip(dvs, inline_d): + actual = np.asarray(totals[obj, dv]).reshape(expected.shape) + np.testing.assert_allclose(actual, expected, rtol=1e-7, atol=1e-7 * np.max(np.abs(expected))) diff --git a/tests/test_pytest.py b/tests/test_pytest.py deleted file mode 100644 index 698475b..0000000 --- a/tests/test_pytest.py +++ /dev/null @@ -1,86 +0,0 @@ -import pytest -import numpy as np - - -def add_two_integers(x,y): - - if not isinstance(x, int): - raise TypeError(f'{x} is not an integer.') - if not isinstance(y, int): - raise TypeError(f'{y} is not an integer.') - return x+y - -''' -Test to make sure desired output is correct -''' -def test_sample_add_1(): - ''' - Test description: make sure integers are added correctly. - ''' - - # Import class/function to test - - # Run test scenario - input_val = 3 - desired_val = 6 - actual_val = add_two_integers( - input_val, - input_val - ) - - # Check to make sure values are correct - np.testing.assert_almost_equal( - actual_val, - desired_val, - decimal = 7, - ) - -''' -Test to make sure desired output is correct -''' -def test_sample_add_2(): - ''' - Test description: make sure integers are added correctly. - ''' - - # Import class/function to test - - # Run test scenario - input_val = 4 - desired_val = 8 - actual_val = add_two_integers( - input_val, - input_val - ) - - # Check to make sure values are correct - assert actual_val == desired_val - - -''' -Test to make sure exceptions are raised -''' -def test_add_exception(): - - ''' - Test description: if input is not an integer, error should be raised - ''' - - # Import class/function to test - - # Check to make sure exceptions are raised - with pytest.raises(Exception) as exc_info: - - # Run test scenario - input_val = 4.5 - actual_val = add_two_integers( - input_val, - input_val - ) - - # Make sure the correct errors are being raised - assert exc_info.type is TypeError - assert str(exc_info.value) == '4.5 is not an integer.' - - - diff --git a/tests/test_regression.py b/tests/test_regression.py new file mode 100644 index 0000000..84199fc --- /dev/null +++ b/tests/test_regression.py @@ -0,0 +1,27 @@ +""" +Golden-value regression tests: K, M, F, U, displacements, rotations, stresses, +objective and gradients of the test models against tests/data/reference.npz. + +After an intended change of results, regenerate the reference with +``python tests/generate_reference.py`` and review the differences. +""" +import os +import numpy as np +import pytest +from models import MODELS, results + +REFERENCE = np.load(os.path.join(os.path.dirname(__file__), 'data', 'reference.npz')) + + +@pytest.mark.parametrize('name', list(MODELS)) +def test_matches_reference(recorder, name): + out = results(name) + keys = sorted(key.split('/', 1)[1] for key in REFERENCE.files if key.startswith(name + '/')) + assert sorted(out) == keys + + for key in keys: + reference = REFERENCE[f'{name}/{key}'] + # gradients go through the adjoint solve and are more sensitive to rounding + rtol = 1e-6 if key.startswith('d_') else 1e-9 + np.testing.assert_allclose(out[key], reference, rtol=rtol, atol=rtol * np.max(np.abs(reference)), + err_msg=f'{name}: {key}') diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000..e2492a9 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,67 @@ +"""Meshing, load transfer and plotting utilities.""" +import numpy as np +import pytest +import aframe as af +from aframe.utils import plot_matplotlib +from aframe.utils.aeroelastic_utils import NodalMap + + +def test_mesh_from_points_and_edges(): + points = np.array([[0, 0, 0], [1, 1, 1], [2, 0, 0], [1, -1, 1]]) + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 0]]) + mesh = af.mesh_from_points_and_edges(points, edges, 5) + + assert mesh.shape == (4, 5, 3) + for (start, end), edge_mesh in zip(edges, mesh): + np.testing.assert_array_equal(edge_mesh[0], points[start]) + np.testing.assert_array_equal(edge_mesh[-1], points[end]) + np.testing.assert_allclose(np.diff(edge_mesh, axis=0), np.tile((points[end] - points[start]) / 4, (4, 1))) + + +@pytest.mark.parametrize('method', ['rbf', 'idw']) +def test_nodal_map(method): + mesh_in = np.zeros((10, 3)) + mesh_in[:, 0] = np.linspace(0, 10, 10) + mesh_out = np.zeros((12, 3)) + mesh_out[:, 0] = np.linspace(0, 10, 12) + mesh_out[:, 1] = 0.2 + + nodal_map = NodalMap(mesh_in, mesh_out, method=method) + # normalized weights map a constant field exactly + shift = np.tile([0.5, -1.0, 2.0], (10, 1)) + np.testing.assert_allclose(nodal_map.evaluate(shift), mesh_out + shift[0]) + + +def test_nodal_map_invalid_method(): + with pytest.raises(ValueError): + NodalMap(np.zeros((2, 3)), np.ones((2, 3)), method='nope').evaluate(np.zeros((2, 3))) + + +def test_matplotlib_outlines(): + mesh = np.stack([np.linspace(0, 5, 6), np.linspace(-1, 2, 6) ** 2, np.linspace(0, 1, 6)], axis=1) + radius = np.full(5, 0.3) + circles = plot_matplotlib.plot_circle(mesh, radius, 12) + boxes = plot_matplotlib.plot_box(mesh, np.full(5, 0.5), np.full(5, 0.2)) + assert len(circles) == len(boxes) == 5 + + for i, circle in enumerate(circles): + points = np.array(circle[0]) + axis = mesh[i + 1] - mesh[i] + midpoint = (mesh[i] + mesh[i + 1]) / 2 + # circle points are at the radius from the midpoint, normal to the element + np.testing.assert_allclose(np.linalg.norm(points - midpoint, axis=1), radius[i]) + np.testing.assert_allclose((points - midpoint) @ axis, 0, atol=1e-12) + assert np.array(boxes[i][0]).shape == (4, 3) + + +def test_pyvista_helpers(): + pv = pytest.importorskip('pyvista') + mesh = np.stack([np.linspace(0, 5, 6), np.linspace(0, 1, 6), np.zeros(6)], axis=1) + plotter = pv.Plotter(off_screen=True) + af.plot_mesh(plotter, mesh) + af.plot_mesh(plotter, mesh, cell_data=np.arange(5.0)) + af.plot_points(plotter, mesh) + af.plot_cyl(plotter, mesh, np.full(5, 0.1), cell_data=np.arange(5.0)) + af.plot_box(plotter, mesh, np.full(5, 0.2), np.full(5, 0.1)) + assert len(plotter.actors) == 13 + plotter.close() diff --git a/tutorials/advanced_tutorials/modopt_tutorial.ipynb b/tutorials/advanced_tutorials/modopt_tutorial.ipynb deleted file mode 100644 index 14e9b87..0000000 --- a/tutorials/advanced_tutorials/modopt_tutorial.ipynb +++ /dev/null @@ -1,406 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# A simple example (unconstrained)\n", - "\n", - "## Define your problem\n", - "\n", - "Let's start with a simple problem of minimizing $x_1^4 + x_2^4$ with respect to $x_1$ and $x_2$.\n", - "\n", - "The mathematical problem statement is: \n", - "\n", - "\n", - "$$\n", - "\\underset{x_1, x_2 \\in \\mathbb{R}}{\\text{minimize}} \\quad x_1^4 + x_2^4\n", - "$$\n", - "\n", - "We know the solution of this problem is $x_1=0$, and $x_2=0$.\n", - "However, we start from an intial guess of $x_1=0.3$, and $x_2=0.3$ for the purposes of this tutorial.\n", - "\n", - "The problem is written in modOpt using the **Problem()** class as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from modopt.api import Problem\n", - "\n", - "\n", - "class X4(Problem):\n", - " def initialize(self, ):\n", - " # Name your problem\n", - " self.problem_name = 'x^4'\n", - "\n", - " def setup(self):\n", - " # Add design variables of your problem\n", - " self.add_design_variables('x',\n", - " shape=(2, ),\n", - " vals=np.array([.3, .3]))\n", - " self.add_objective('f')\n", - "\n", - " def setup_derivatives(self):\n", - " # Declare objective gradient and its shape\n", - " self.declare_objective_gradient(wrt='x', )\n", - "\n", - " # Compute the value of the objective with given design variable values\n", - " def compute_objective(self, dvs, obj):\n", - " obj['f'] = np.sum(dvs['x']**4)\n", - "\n", - " def compute_objective_gradient(self, dvs, grad):\n", - " grad['x'] = 4 * dvs['x']**3" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Develop/Build your optimization algorithm\n", - "\n", - "Here we look at the **steepest descent** algorithm for unconstrained problems. \n", - "We will later (in the next section) use it to solve the unconstrained optimization problem defined above.\n", - "\n", - "For a general unconstrained optimization problem stated as: \n", - "\n", - "$$\n", - "\\underset{x \\in \\mathbb{R^n}}{\\text{minimize}} \\quad f(x)\n", - "$$\n", - "\n", - "the steepest descent algorithms computes the new iterate recursively by using the formula\n", - "\n", - "$$\n", - "x_{k+1} = x_{k} - \\nabla f(x_k) .\n", - "$$\n", - "\n", - "Given an initial guess $x_0$, we can write an optimizer using the steepest descent algorithm using the **Optimizer()** class in modOpt as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import time\n", - "from modopt.api import Optimizer\n", - "\n", - "\n", - "class SteepestDescent(Optimizer):\n", - " def initialize(self):\n", - "\n", - " # Name your algorithm\n", - " self.solver_name = 'steepest_descent'\n", - "\n", - " self.obj = self.problem._compute_objective\n", - " self.grad = self.problem._compute_objective_gradient\n", - "\n", - " self.options.declare('max_itr', default=1000, types=int)\n", - " self.options.declare('opt_tol', default=1e-5, types=float)\n", - "\n", - " # Specify format of outputs available from your optimizer after each iteration\n", - " self.default_outputs_format = {\n", - " 'itr': int,\n", - " 'obj': float,\n", - " # for arrays from each iteration, shapes need to be declared\n", - " 'x': (float, (self.problem.nx, )),\n", - " 'opt': float,\n", - " 'time': float,\n", - " }\n", - "\n", - " # Enable user to specify, as a list, which among the available outputs\n", - " # need to be stored in memory and written to output files\n", - " self.options.declare('outputs',\n", - " types=list,\n", - " default=['itr', 'obj', 'x', 'opt', 'time'])\n", - "\n", - " def solve(self):\n", - " nx = self.problem.nx\n", - " x = self.problem.x.get_data()\n", - " opt_tol = self.options['opt_tol']\n", - " max_itr = self.options['max_itr']\n", - "\n", - " obj = self.obj\n", - " grad = self.grad\n", - "\n", - " start_time = time.time()\n", - "\n", - " # Setting intial values for initial iterates\n", - " x_k = x * 1.\n", - " f_k = obj(x_k)\n", - " g_k = grad(x_k)\n", - "\n", - " # Iteration counter\n", - " itr = 0\n", - "\n", - " # Optimality\n", - " opt = np.linalg.norm(g_k)\n", - "\n", - " # Initializing outputs\n", - " self.update_outputs(itr=0,\n", - " x=x_k,\n", - " obj=f_k,\n", - " opt=opt,\n", - " time=time.time() - start_time)\n", - "\n", - " while (opt > opt_tol and itr < max_itr):\n", - " itr_start = time.time()\n", - " itr += 1\n", - "\n", - " # ALGORITHM STARTS HERE\n", - " # >>>>>>>>>>>>>>>>>>>>>\n", - "\n", - " p_k = -g_k\n", - "\n", - " x_k += p_k\n", - " f_k = obj(x_k)\n", - " g_k = grad(x_k)\n", - "\n", - " opt = np.linalg.norm(g_k)\n", - "\n", - " # <<<<<<<<<<<<<<<<<<<\n", - " # ALGORITHM ENDS HERE\n", - "\n", - " # Append arrays inside outputs dict with new values from the current iteration\n", - " self.update_outputs(itr=itr,\n", - " x=x_k,\n", - " obj=f_k,\n", - " opt=opt,\n", - " time=time.time() - start_time)\n", - "\n", - " # Run post-processing for the Optimizer() base class\n", - " self.run_post_processing()\n", - "\n", - " end_time = time.time()\n", - " self.total_time = end_time - start_time" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The **Optimizer()** class records all the data needed using the `outputs` dictionary.\n", - "\n", - "## Solve your problem using your optimizer\n", - "\n", - "Now that we have modeled the problem and developed the optimizer, the task remaining is to solve the problem with the optimizer.\n", - "For this, we need to set up our optimizer with the problem and pass in optimizer-specific parameters. \n", - "Default values will be assumed if the optimizer parameters are not passed in." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Setting objective name as \"f\".\n", - "\n", - "----------------------------------------------------------------------------\n", - "Derivative type | Calc norm | FD norm | Abs error norm | Rel error norm \n", - "----------------------------------------------------------------------------\n", - "\n", - "Gradient | 1.5274e-01 | 1.5274e-01 | 7.6367e-07 | 7.0710e-06 \n", - "----------------------------------------------------------------------------\n", - "\n", - "\n", - " \t ===============================\n", - "\t ModOpt final iteration summary:\n", - "\t ===============================\n", - "\t Problem : x^4\n", - "\t Solver : steepest_descent\n", - "\t itr : 100\n", - "\t obj : 2.8304561425587446e-06\n", - "\t opt : 0.0002321105148388349\n", - "\t time : 1.0574009418487549\n", - "\t =====================================\n", - "\n", - "\n", - "===============================\n", - " modOpt summary table: \n", - "===============================\n", - " itr obj opt time\n", - " 0 1.62E-02 1.53E-01 7.99E-05\n", - " 1 2.72E-03 4.00E-02 2.46E-02\n", - " 2 1.44E-03 2.48E-02 3.17E-02\n", - " 3 9.12E-04 1.77E-02 3.89E-02\n", - " 4 6.38E-04 1.35E-02 4.64E-02\n", - " 5 4.74E-04 1.08E-02 5.39E-02\n", - " 6 3.68E-04 8.94E-03 6.02E-02\n", - " 7 2.94E-04 7.56E-03 6.75E-02\n", - " 8 2.41E-04 6.51E-03 7.30E-02\n", - " 9 2.02E-04 5.69E-03 8.02E-02\n", - " 10 1.71E-04 5.03E-03 8.60E-02\n", - " 11 1.47E-04 4.49E-03 9.16E-02\n", - " 12 1.28E-04 4.05E-03 9.81E-02\n", - " 13 1.12E-04 3.67E-03 1.06E-01\n", - " 14 9.95E-05 3.35E-03 1.16E-01\n", - " 15 8.87E-05 3.07E-03 1.25E-01\n", - " 16 7.96E-05 2.84E-03 1.33E-01\n", - " 17 7.19E-05 2.63E-03 1.41E-01\n", - " 18 6.52E-05 2.44E-03 1.49E-01\n", - " 19 5.95E-05 2.28E-03 1.56E-01\n", - " 20 5.45E-05 2.13E-03 1.62E-01\n", - " 21 5.01E-05 2.00E-03 2.20E-01\n", - " 22 4.62E-05 1.88E-03 2.37E-01\n", - " 23 4.27E-05 1.78E-03 2.50E-01\n", - " 24 3.96E-05 1.68E-03 2.60E-01\n", - " 25 3.69E-05 1.59E-03 2.70E-01\n", - " 26 3.44E-05 1.51E-03 2.86E-01\n", - " 27 3.22E-05 1.44E-03 2.97E-01\n", - " 28 3.02E-05 1.37E-03 3.08E-01\n", - " 29 2.83E-05 1.31E-03 3.19E-01\n", - " 30 2.67E-05 1.25E-03 3.29E-01\n", - " 31 2.52E-05 1.19E-03 3.40E-01\n", - " 32 2.38E-05 1.14E-03 3.47E-01\n", - " 33 2.25E-05 1.10E-03 3.60E-01\n", - " 34 2.13E-05 1.05E-03 3.71E-01\n", - " 35 2.02E-05 1.01E-03 3.79E-01\n", - " 36 1.92E-05 9.75E-04 3.89E-01\n", - " 37 1.83E-05 9.40E-04 3.97E-01\n", - " 38 1.74E-05 9.06E-04 4.04E-01\n", - " 39 1.66E-05 8.74E-04 4.10E-01\n", - " 40 1.58E-05 8.44E-04 4.19E-01\n", - " 41 1.51E-05 8.16E-04 4.25E-01\n", - " 42 1.45E-05 7.89E-04 4.33E-01\n", - " 43 1.39E-05 7.64E-04 4.42E-01\n", - " 44 1.33E-05 7.40E-04 4.49E-01\n", - " 45 1.28E-05 7.18E-04 4.57E-01\n", - " 46 1.22E-05 6.96E-04 4.65E-01\n", - " 47 1.18E-05 6.76E-04 4.73E-01\n", - " 48 1.13E-05 6.56E-04 4.80E-01\n", - " 49 1.09E-05 6.38E-04 4.87E-01\n", - " 50 1.05E-05 6.20E-04 4.94E-01\n", - " 51 1.01E-05 6.03E-04 5.03E-01\n", - " 52 9.75E-06 5.87E-04 5.10E-01\n", - " 53 9.41E-06 5.72E-04 5.17E-01\n", - " 54 9.09E-06 5.57E-04 5.24E-01\n", - " 55 8.78E-06 5.43E-04 5.32E-01\n", - " 56 8.49E-06 5.29E-04 5.40E-01\n", - " 57 8.22E-06 5.16E-04 5.47E-01\n", - " 58 7.95E-06 5.04E-04 5.55E-01\n", - " 59 7.70E-06 4.92E-04 5.62E-01\n", - " 60 7.46E-06 4.80E-04 5.70E-01\n", - " 61 7.24E-06 4.69E-04 5.77E-01\n", - " 62 7.02E-06 4.59E-04 5.84E-01\n", - " 63 6.81E-06 4.48E-04 5.92E-01\n", - " 64 6.61E-06 4.39E-04 6.00E-01\n", - " 65 6.42E-06 4.29E-04 6.08E-01\n", - " 66 6.24E-06 4.20E-04 6.18E-01\n", - " 67 6.06E-06 4.11E-04 6.30E-01\n", - " 68 5.90E-06 4.02E-04 6.40E-01\n", - " 69 5.74E-06 3.94E-04 6.52E-01\n", - " 70 5.58E-06 3.86E-04 6.61E-01\n", - " 71 5.43E-06 3.79E-04 6.76E-01\n", - " 72 5.29E-06 3.71E-04 6.86E-01\n", - " 73 5.16E-06 3.64E-04 6.98E-01\n", - " 74 5.03E-06 3.57E-04 7.13E-01\n", - " 75 4.90E-06 3.50E-04 7.26E-01\n", - " 76 4.78E-06 3.44E-04 7.39E-01\n", - " 77 4.66E-06 3.37E-04 7.54E-01\n", - " 78 4.55E-06 3.31E-04 7.68E-01\n", - " 79 4.44E-06 3.25E-04 7.80E-01\n", - " 80 4.33E-06 3.20E-04 7.93E-01\n", - " 81 4.23E-06 3.14E-04 8.07E-01\n", - " 82 4.14E-06 3.08E-04 8.19E-01\n", - " 83 4.04E-06 3.03E-04 8.33E-01\n", - " 84 3.95E-06 2.98E-04 8.50E-01\n", - " 85 3.86E-06 2.93E-04 8.65E-01\n", - " 86 3.78E-06 2.88E-04 8.80E-01\n", - " 87 3.69E-06 2.83E-04 8.96E-01\n", - " 88 3.61E-06 2.79E-04 9.10E-01\n", - " 89 3.54E-06 2.74E-04 9.27E-01\n", - " 90 3.46E-06 2.70E-04 9.41E-01\n", - " 91 3.39E-06 2.66E-04 9.57E-01\n", - " 92 3.32E-06 2.62E-04 9.70E-01\n", - " 93 3.25E-06 2.58E-04 9.83E-01\n", - " 94 3.19E-06 2.54E-04 9.96E-01\n", - " 95 3.12E-06 2.50E-04 1.01E+00\n", - " 96 3.06E-06 2.46E-04 1.02E+00\n", - " 97 3.00E-06 2.42E-04 1.03E+00\n", - " 98 2.94E-06 2.39E-04 1.04E+00\n", - " 99 2.89E-06 2.35E-04 1.05E+00\n", - " 100 2.83E-06 2.32E-04 1.06E+00\n", - "===============================\n", - "\n", - "\n", - "100\n", - "[0.03449107 0.03449107]\n", - "1.0574009418487549\n", - "2.8304561425587446e-06\n", - "0.0002321105148388349\n" - ] - } - ], - "source": [ - "# Set your optimality tolerance\n", - "opt_tol = 1E-8\n", - "# Set maximum optimizer iteration limit\n", - "max_itr = 100\n", - "\n", - "prob = X4()\n", - "\n", - "# Set up your optimizer with your problem and pass in optimizer parameters\n", - "# And declare outputs to be stored\n", - "optimizer = SteepestDescent(prob,\n", - " opt_tol=opt_tol,\n", - " max_itr=max_itr,\n", - " outputs=['itr', 'obj', 'x', 'opt', 'time'])\n", - "\n", - "# Check first derivatives at the initial guess, if needed\n", - "optimizer.check_first_derivatives(prob.x.get_data())\n", - "\n", - "# Solve your optimization problem\n", - "optimizer.solve()\n", - "\n", - "# Print results of optimization (summary_table contains information from each iteration)\n", - "optimizer.print_results(summary_table=True)\n", - "\n", - "# Print any output that was declared\n", - "# Since the arrays are long, here we only print the last entry and\n", - "# verify it with the print_results() above\n", - "\n", - "print('\\n')\n", - "print(optimizer.outputs['itr'][-1])\n", - "print(optimizer.outputs['x'][-1])\n", - "print(optimizer.outputs['time'][-1])\n", - "print(optimizer.outputs['obj'][-1])\n", - "print(optimizer.outputs['opt'][-1])" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tutorials/basic_tutorials/jupyter_tutorial.ipynb b/tutorials/basic_tutorials/jupyter_tutorial.ipynb deleted file mode 100644 index 7771421..0000000 --- a/tutorials/basic_tutorials/jupyter_tutorial.ipynb +++ /dev/null @@ -1,72 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Paraboloid example" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "x = np.linspace(-50, 50, 100)\n", - "y = np.linspace(-50, 50, 100)\n", - "XX, YY = np.meshgrid(x, y)\n", - "ZZ = (XX - 3)**2 + XX * YY + (YY + 4)**2 - 3\n", - "\n", - "plt.figure(figsize=(8, 6))\n", - "plt.contour(XX, YY, ZZ, levels=np.linspace(np.min(ZZ), np.max(ZZ), 50))\n", - "plt.xlabel('x')\n", - "plt.ylabel('y')\n", - "plt.colorbar(label='f')\n", - "plt.suptitle('Contour of the paraboloid', fontsize=18);" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.9.13 64-bit", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}