lamkit 0.1.0__tar.gz → 0.1.2__tar.gz

{lamkit-0.1.0 → lamkit-0.1.2}/.gitignore

@@ -27,3 +27,7 @@ docs/_build/
 # IDE
 .idea/
 .vscode/
+
+# Data
+
+data/

lamkit-0.1.2/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: lamkit
+Version: 0.1.2
+Summary: Toolkit for stress analysis and failure prediction of composite laminates with holes and joints.
+Project-URL: Homepage, https://github.com/swayli94/lamkit
+Project-URL: Documentation, https://swayli94.github.io/lamkit/
+Project-URL: Repository, https://github.com/swayli94/lamkit
+Project-URL: Issues, https://github.com/swayli94/lamkit/issues
+Author: Runze Li
+License: MIT License
+        
+        Copyright (c) 2026 Runze LI
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: bjsfm,buckling,composite,engineering,laminate,open-hole,stress analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.1; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo>=2024.8.6; extra == 'docs'
+Requires-Dist: myst-parser>=4.0; extra == 'docs'
+Requires-Dist: sphinx>=8.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# lamkit
+
+`lamkit` is a Python toolkit for composite laminate analysis, focused on:
+
+- Laminate stress/strain response based on Classical Lamination Theory (CLT)
+- LaRC05 failure index evaluation
+- Lekhnitskii open-hole infinite-plate analytical solution
+- Open-hole plate's effective (homogenisation) properties
+- Linear buckling analysis of laminates
+- Objective/constraint evaluation for laminate optimization tasks
+
+## Installation
+
+### Requirements
+
+- Python `>=3.9`
+- Core dependencies: `numpy`, `pandas`, `matplotlib`
+
+### Install from PyPI
+
+```bash
+pip install lamkit
+```
+
+### Install for local development
+
+```bash
+pip install -e .[dev,docs]
+```
+
+## Quick Start
+
+The following example creates a laminate and evaluates ply-surface fields under membrane loading:
+
+```python
+import numpy as np
+from lamkit import Laminate, Ply
+from lamkit.analysis.material import IM7_8551_7
+
+ply = Ply(IM7_8551_7, thickness=0.125)  # mm
+stacking = [45, -45, 0, 90, 90, 0, -45, 45]
+laminate = Laminate(stacking=stacking, plies=ply)
+
+# N = [Nxx, Nyy, Nxy, Mxx, Myy, Mxy]
+N = np.array([80.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+field = laminate.evaluate_laminate(N)
+
+print(field[["index_ply", "index_surface", "z", "sigma_1", "sigma_2", "tau_12", "FI_max"]].head())
+```
+
+## Examples
+
+The `example/` directory contains runnable scripts:
+
+1. **Laminate response (CLT + LaRC05)**  
+   `example/1-laminate/example_laminate.py`  
+   Computes through-thickness stress/strain and LaRC05 index distributions with plots.
+
+2. **Lekhnitskii unloaded-hole solution**  
+   `example/2-lekhnitskii-solution/example_unloaded_hole.py`  
+   Solves and visualizes open-hole stress fields.
+
+3. **Laminate open-hole field analysis**  
+   `example/3-open-hole/example_open_hole.py`  
+   Couples laminate equivalent compliance with open-hole fields and generates failure envelopes/boundary maps.
+
+4. **Effective stiffness with hole homogenization**  
+   `example/4-effective-stiffness/example_effective_stiffness.py`  
+   Compares laminate stiffness `A` (without hole) and homogenized stiffness `A_eff` (with hole).
+
+5. **Laminate linear buckling**  
+   `example/5-laminate-buckling/example_buckling.py`  
+   Computes buckling eigenvalues and saves buckling mode plots.
+
+6. **Optimization objective/constraint evaluation**  
+   `example/6-laminate-optimization-task/example_laminate_opt_function.py`  
+   Demonstrates combined displacement, failure, and buckling constraint evaluation for design tasks.
+
+## Common Development Commands
+
+### Run tests
+
+```bash
+pytest
+```
+
+### Build distribution package
+
+```bash
+python -m build
+```
+
+### Build documentation
+
+```bash
+cd docs
+sphinx-build -b html . _build/html
+```

lamkit-0.1.2/README.md

@@ -0,0 +1,98 @@
+# lamkit
+
+`lamkit` is a Python toolkit for composite laminate analysis, focused on:
+
+- Laminate stress/strain response based on Classical Lamination Theory (CLT)
+- LaRC05 failure index evaluation
+- Lekhnitskii open-hole infinite-plate analytical solution
+- Open-hole plate's effective (homogenisation) properties
+- Linear buckling analysis of laminates
+- Objective/constraint evaluation for laminate optimization tasks
+
+## Installation
+
+### Requirements
+
+- Python `>=3.9`
+- Core dependencies: `numpy`, `pandas`, `matplotlib`
+
+### Install from PyPI
+
+```bash
+pip install lamkit
+```
+
+### Install for local development
+
+```bash
+pip install -e .[dev,docs]
+```
+
+## Quick Start
+
+The following example creates a laminate and evaluates ply-surface fields under membrane loading:
+
+```python
+import numpy as np
+from lamkit import Laminate, Ply
+from lamkit.analysis.material import IM7_8551_7
+
+ply = Ply(IM7_8551_7, thickness=0.125)  # mm
+stacking = [45, -45, 0, 90, 90, 0, -45, 45]
+laminate = Laminate(stacking=stacking, plies=ply)
+
+# N = [Nxx, Nyy, Nxy, Mxx, Myy, Mxy]
+N = np.array([80.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+field = laminate.evaluate_laminate(N)
+
+print(field[["index_ply", "index_surface", "z", "sigma_1", "sigma_2", "tau_12", "FI_max"]].head())
+```
+
+## Examples
+
+The `example/` directory contains runnable scripts:
+
+1. **Laminate response (CLT + LaRC05)**  
+   `example/1-laminate/example_laminate.py`  
+   Computes through-thickness stress/strain and LaRC05 index distributions with plots.
+
+2. **Lekhnitskii unloaded-hole solution**  
+   `example/2-lekhnitskii-solution/example_unloaded_hole.py`  
+   Solves and visualizes open-hole stress fields.
+
+3. **Laminate open-hole field analysis**  
+   `example/3-open-hole/example_open_hole.py`  
+   Couples laminate equivalent compliance with open-hole fields and generates failure envelopes/boundary maps.
+
+4. **Effective stiffness with hole homogenization**  
+   `example/4-effective-stiffness/example_effective_stiffness.py`  
+   Compares laminate stiffness `A` (without hole) and homogenized stiffness `A_eff` (with hole).
+
+5. **Laminate linear buckling**  
+   `example/5-laminate-buckling/example_buckling.py`  
+   Computes buckling eigenvalues and saves buckling mode plots.
+
+6. **Optimization objective/constraint evaluation**  
+   `example/6-laminate-optimization-task/example_laminate_opt_function.py`  
+   Demonstrates combined displacement, failure, and buckling constraint evaluation for design tasks.
+
+## Common Development Commands
+
+### Run tests
+
+```bash
+pytest
+```
+
+### Build distribution package
+
+```bash
+python -m build
+```
+
+### Build documentation
+
+```bash
+cd docs
+sphinx-build -b html . _build/html
+```

lamkit-0.1.2/docs/api.rst

@@ -0,0 +1,69 @@
+API reference
+=============
+
+Top-level package
+-----------------
+
+.. automodule:: lamkit
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Analysis
+--------
+
+.. automodule:: lamkit.analysis.material
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.analysis.laminate
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.analysis.larc05
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.analysis.buckling
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Lekhnitskii
+-----------
+
+.. automodule:: lamkit.lekhnitskii.hole
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.lekhnitskii.unloaded_hole
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.lekhnitskii.loaded_hole
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.lekhnitskii.homogenisation
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Utilities and requirements
+--------------------------
+
+.. automodule:: lamkit.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+.. automodule:: lamkit.requirements
+   :members:
+   :undoc-members:
+   :show-inheritance:

lamkit-0.1.2/docs/examples.rst

@@ -0,0 +1,40 @@
+Examples
+========
+
+The repository contains runnable examples in the ``example/`` directory.
+
+1. Laminate response (CLT + LaRC05)
+-----------------------------------
+
+- Path: ``example/1-laminate/example_laminate.py``
+- Computes laminate response through thickness and plots strain/stress/FI profiles.
+
+2. Lekhnitskii unloaded-hole solution
+-------------------------------------
+
+- Path: ``example/2-lekhnitskii-solution/example_unloaded_hole.py``
+- Solves open-hole stress and displacement fields for a homogeneous equivalent plate.
+
+3. Open-hole laminate field
+---------------------------
+
+- Path: ``example/3-open-hole/example_open_hole.py``
+- Couples laminate equivalent compliance with open-hole field and LaRC05 envelopes.
+
+4. Effective stiffness with hole homogenisation
+-----------------------------------------------
+
+- Path: ``example/4-effective-stiffness/example_effective_stiffness.py``
+- Compares laminate in-plane properties with homogenized open-hole effective properties.
+
+5. Laminate buckling
+--------------------
+
+- Path: ``example/5-laminate-buckling/example_buckling.py``
+- Runs linear buckling eigenvalue analysis and saves mode-shape plots.
+
+6. Laminate optimization objective/constraints
+----------------------------------------------
+
+- Path: ``example/6-laminate-optimization-task/example_laminate_opt_function.py``
+- Demonstrates combined displacement/failure/buckling constraint evaluation.

lamkit-0.1.2/docs/index.rst

@@ -0,0 +1,19 @@
+lamkit documentation
+====================
+
+`lamkit` is a Python toolkit for composite laminate analysis, including:
+
+- classical laminate theory (CLT) stiffness and ply-level response
+- LaRC05 failure index evaluation
+- open-hole field prediction (Lekhnitskii solution)
+- laminate plate linear buckling analysis
+- layup engineering requirement checks
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents
+
+   installation
+   quickstart
+   examples
+   api

lamkit-0.1.2/docs/installation.rst

@@ -0,0 +1,39 @@
+Installation
+============
+
+Requirements
+------------
+
+- Python 3.9+
+- pip
+
+Install from source
+-------------------
+
+.. code-block:: bash
+
+   pip install -e .[dev,docs]
+
+Install from PyPI
+-----------------
+
+.. code-block:: bash
+
+   pip install lamkit
+
+Optional runtime dependencies
+-----------------------------
+
+- Buckling analysis uses SciPy:
+
+  .. code-block:: bash
+
+     pip install scipy
+
+Build documentation locally
+---------------------------
+
+.. code-block:: bash
+
+   cd docs
+   sphinx-build -b html . _build/html

lamkit-0.1.2/docs/quickstart.rst

@@ -0,0 +1,55 @@
+Quickstart
+==========
+
+The package exports the main classes directly from ``lamkit``:
+
+.. code-block:: python
+
+   from lamkit import Material, Ply, Laminate, LaRC05, Hole, UnloadedHole
+
+Build a simple laminate and evaluate ply-level response:
+
+.. code-block:: python
+
+   import numpy as np
+   from lamkit import Laminate, Ply
+   from lamkit.analysis.material import IM7_8551_7
+
+   ply = Ply(IM7_8551_7, thickness=0.125)
+   stacking = [0.0, 45.0, -45.0, 90.0, 90.0, -45.0, 45.0, 0.0]
+   lam = Laminate(stacking=stacking, plies=ply)
+
+   # [Nxx, Nyy, Nxy, Mxx, Myy, Mxy]
+   N = np.array([80.0, 0.0, 0.0, 0.0, 0.0, 0.0])
+   field = lam.evaluate_laminate(N)
+
+   print(field[["index_ply", "index_surface", "sigma_1", "FI_max"]].head())
+   print("global FI_max =", field.attrs["global_FI_max"])
+
+Evaluate an open-hole plate for the same laminate:
+
+.. code-block:: python
+
+   import numpy as np
+   from lamkit.utils import evaluate_unloaded_hole_plate
+   from lamkit.lekhnitskii.utils import generate_meshgrid
+
+   mesh = generate_meshgrid(
+       hole_radius=1.0,
+       plate_radius=8.0,
+       n_points_radial=121,
+       n_points_angular=121,
+   )
+
+   results_by_plies, mid_plane = evaluate_unloaded_hole_plate(
+       laminate=lam,
+       hole_radius=1.0,
+       sigma_xx_inf=100.0,
+       sigma_yy_inf=0.0,
+       tau_xy_inf=0.0,
+       x=mesh["X"],
+       y=mesh["Y"],
+   )
+
+   print("mid-plane sigma_x max =", np.max(mid_plane["sigma_x"]))
+   print("ply-surface FI_max max =", max(np.max(p["FI_max"]) for p in results_by_plies))

{lamkit-0.1.0 → lamkit-0.1.2}/example/4-effective-stiffness/example_effective_stiffness.py

@@ -96,6 +96,10 @@ def calculate_effective_properties(laminate: Laminate,
         'A_eff': properties_eff['A_eff'],
         'S_lam': S_lam,
         'S_eff': properties_eff['S_eff'],
+        'disp_right_list': properties_eff['disp_right_list'],
+        'disp_left_list': properties_eff['disp_left_list'],
+        'disp_top_list': properties_eff['disp_top_list'],
+        'disp_bottom_list': properties_eff['disp_bottom_list'],
     }
     
     for key in ['E11', 'E22', 'G12', 'nu12']:
@@ -153,26 +157,30 @@ def print_comparison(results: Dict[str, Any]) -> None:
 def main() -> None:
     
     # Example laminate (quasi-isotropic).
+    layup = [0]
+    layup = [90]
+    layup = [45, -45, 0, 90, 90, 0, -45, 45]
     layup = [45, -45, 0, -45, 45, 0, 0, 90, 90, 0, 0, 45, -45, 0, -45, 45]
-    ply_thickness_mm = 0.125
-
-    ply = Ply(material=IM7_8551_7, thickness=ply_thickness_mm)
-    laminate = Laminate(stacking=layup, plies=ply)
 
     # Plot ratio curves of effective properties vs. laminate reference.
     #   {prop}_eff / {prop}_lam, where prop in [E11, E22, G12, nu12].
     properties = ["E11", "E22", "G12", "nu12"]
 
-    r_list = [1, 10]  # mm
-    w_r_ratios = [2.2, 2.4, 2.6, 2.8, 3.0, 3.5, 4, 5] + [i for i in range(6, 21, 2)]  # w/r ratio
+    case_list = [(1, 0.1), (2, 1.0)]  # (r_mm, ply_thickness_mm)
+    w_r_ratios = [2.1, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5,
+                  5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 25, 30, 35, 40, 45, 50]  # w/r ratio
 
-    # ratios[prop][i_r, i_wr] = prop_eff / prop_lam
+    # ratios[prop][i_curve, i_wr] = prop_eff / prop_lam
     ratios: Dict[str, np.ndarray] = {
-        prop: np.zeros((len(r_list), len(w_r_ratios)), dtype=float)
+        prop: np.zeros((len(case_list), len(w_r_ratios)), dtype=float)
         for prop in properties
     }
 
-    for i_r, r_mm in enumerate(r_list):
+    for i_curve, (r_mm, ply_thickness_mm) in enumerate(case_list):
+        
+        ply = Ply(material=IM7_8551_7, thickness=ply_thickness_mm)
+        laminate = Laminate(stacking=layup, plies=ply)
+        
         for i_wr, w_r_ratio in enumerate(w_r_ratios):
             w_plate_mm = float(w_r_ratio) * float(r_mm)
 
@@ -189,26 +197,26 @@ def main() -> None:
             for prop in properties:
                 lam_val = float(results[f"{prop}_lam"])
                 eff_val = float(results[f"{prop}_eff"])
-                ratios[prop][i_r, i_wr] = eff_val / (lam_val + 1e-30)  # avoid division-by-zero
+                ratios[prop][i_curve, i_wr] = eff_val / (lam_val + 1e-30)  # avoid division-by-zero
 
     # --- Plot (2x2 subplots) ---
     fig, axes = plt.subplots(2, 2, figsize=(12, 9), sharex=True)
     axes_flat = axes.ravel()
 
     for ax, prop in zip(axes_flat, properties):
-        for i_r, r_mm in enumerate(r_list):
+        for i_curve, (r_mm, ply_thickness_mm) in enumerate(case_list):
             ax.plot(
                 w_r_ratios,
-                ratios[prop][i_r, :],
+                ratios[prop][i_curve, :],
                 marker="o",
                 linewidth=1.8,
-                label=f"r={r_mm} mm",
+                label=f"r={r_mm} mm, t_ply={ply_thickness_mm} mm",
             )
 
         ax.set_title(prop)
         ax.set_xlabel("w/r")
         ax.set_ylabel(f"Ratio of {prop}")
-        ax.set_xlim(2, 21)
+        ax.set_xlim(2, 51)
         ax.grid(True, alpha=0.3)
         ax.legend(fontsize="small")
 
@@ -221,9 +229,86 @@ def main() -> None:
 
     out_path = os.path.join(path, "images", "open_hole_homogenisation.png")
     fig.savefig(out_path, dpi=200)
-    print(f"Saved plot: {out_path}")
+    
+    # Plot ratio curves of displacements at the boundaries vs. laminate reference.
+    
+    w_r_ratios = [2.1, 2.5, 3, 5, 10]  # w/r ratio
+    r_mm = 1.0
+    colors = ['red', 'orange', 'green', 'blue', 'purple']
+    n_points_boundary = 101
+    magnitude_factor = 1e4
+    
+    ply = Ply(material=IM7_8551_7, thickness=1.0)
+    laminate = Laminate(stacking=layup, plies=ply)
+    
+    fig, axes = plt.subplots(1, 3, figsize=(12, 6), sharex=True)
+    axes_flat = axes.ravel()
 
+    for i_wr, w_r_ratio in enumerate(w_r_ratios):
+        
+        w_plate_mm = float(w_r_ratio) * float(r_mm)
+        coords = w_plate_mm*0.5*np.linspace(-1, 1, n_points_boundary)
+
+        results = calculate_effective_properties(
+            laminate=laminate,
+            lx_plate_mm=w_plate_mm,
+            ly_plate_mm=w_plate_mm,
+            hole_radius_mm=float(r_mm),
+            n_points_boundary=n_points_boundary,
+        )
+        
+        # Displacements (u,v) at the boundaries (right, left, top, bottom)
+        # for 3 unit stress states [sigma_xx_inf, sigma_yy_inf, tau_xy_inf].
+        disp_right_list = results['disp_right_list'] # [3][n_points_boundary, 2]
+        disp_left_list = results['disp_left_list']
+        disp_top_list = results['disp_top_list']
+        disp_bottom_list = results['disp_bottom_list']
+    
+        # Plot displacements: each stress state in one subplot.
+        for i_stress, stress_state in enumerate([r'$\sigma_{xx}^{\infty}$', r'$\sigma_{yy}^{\infty}$', r'$\tau_{xy}^{\infty}$']):
+            
+            if i_wr == 0:
+                axes_flat[i_stress].add_patch(plt.Circle((0, 0), r_mm, color='black', linewidth=1.8, fill=False))
+            
+            axes_flat[i_stress].plot(-0.5*w_plate_mm+disp_left_list[i_stress][:, 0]*magnitude_factor,
+                                    coords+disp_left_list[i_stress][:, 1]*magnitude_factor,
+                                    color=colors[i_wr], linewidth=1.0)
+
+            axes_flat[i_stress].plot( 0.5*w_plate_mm+disp_right_list[i_stress][:, 0]*magnitude_factor,
+                                    coords+disp_right_list[i_stress][:, 1]*magnitude_factor,
+                                    color=colors[i_wr], linewidth=1.0)
+
+            axes_flat[i_stress].plot(coords+disp_bottom_list[i_stress][:, 0]*magnitude_factor, 
+                                    -0.5*w_plate_mm+disp_bottom_list[i_stress][:, 1]*magnitude_factor, 
+                                    color=colors[i_wr], linewidth=1.0)
+
+            axes_flat[i_stress].plot(coords+disp_top_list[i_stress][:, 0]*magnitude_factor,
+                                    0.5*w_plate_mm+disp_top_list[i_stress][:, 1]*magnitude_factor, 
+                                    color=colors[i_wr], linewidth=1.0,
+                                    label=f"w/r={w_r_ratio:.1f}")
+            
+            if i_wr == len(w_r_ratios) - 1:
+                
+                axes_flat[i_stress].set_xlabel('x')
+                axes_flat[i_stress].set_ylabel('y')
+                axes_flat[i_stress].set_title(stress_state)
+                axes_flat[i_stress].grid(True, alpha=0.3)
+                
+                axes_flat[i_stress].set_xlim(-0.8*w_plate_mm, 0.8*w_plate_mm)
+                axes_flat[i_stress].set_ylim(-0.8*w_plate_mm, 0.8*w_plate_mm)
+                axes_flat[i_stress].axis('equal')
+                axes_flat[i_stress].legend(fontsize="small")
 
+    fig.suptitle(
+        f"Open Hole Plate: Displacements at the boundaries\n"+ \
+        f"Layup: {layup}\n"+ \
+        f"Magnify factor: {magnitude_factor:.1e}",
+        fontsize=14,
+    )
+    fig.tight_layout(rect=[0, 0, 1, 1])
+
+    out_path = os.path.join(path, "images", "open_hole_displacements.png")
+    fig.savefig(out_path, dpi=200)
 
 
 if __name__ == "__main__":