From b84bf0dd9efc809bef803b5095804edfa770a682 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 24 Oct 2025 11:13:04 -0600
Subject: [PATCH 01/30] fix typos in installation instructions (#152)

---
 docs/installation.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/installation.md b/docs/installation.md
index dddb95ff..816bf1e8 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -23,7 +23,7 @@ At this point, although not strictly required, we recommend creating a dedicated
 #### On Apple silicon
 For Apple silicon, we recommend installing Ard natively.
 ```shell
-conda CONDA_SUBDIR=osx-arm64 conda create -n ard-env 
+CONDA_SUBDIR=osx-arm64 conda create -n ard-env 
 conda activate ard-env
 conda env config vars set CONDA_SUBDIR=osx-arm64 # this command makes the environment permanently native
 conda install python=3.12
@@ -31,7 +31,7 @@ conda install python=3.12
 
 #### Or, on Intel
 ```shell
-create --name ard-env
+conda create --name ard-env
 conda activate ard-env
 conda install python=3.12 pip mamba -y
 ```

From 1e9c533d08ba23fee246ae3a1959e43d3cc441d8 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 28 Oct 2025 11:40:14 -0600
Subject: [PATCH 02/30] Multi-objective refactor (#153)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* added first cut at multi-objective stuff

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* multi-objective refactor

* fix example code

* black reformat

* invert erroneous exclusion

* improved unit testing

* get rid of pyoptsparse dependencies and broaden test coverage

* fixed erroneous inclusion of options

* address copilot comments

* address jared's requests on #153

* add the file that i renamed the wrong way

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 .gitignore                                    |   3 +-
 ard/api/interface.py                          |  15 +-
 assets/logomaker/inputs/ard_system.yaml       |   5 +-
 examples/01_onshore/inputs/ard_system.yaml    |   5 +-
 .../02_offshore_fixed/inputs/ard_system.yaml  |   5 +-
 .../02_offshore_fixed/optimization_demo.ipynb | 150 ++---
 .../inputs/ard_system.yaml                    |   5 +-
 .../optimization_demo.ipynb                   | 558 ++++++++----------
 .../05_onshore_batch/inputs/ard_system.yaml   |   7 +-
 pyproject.toml                                |   2 +-
 .../inputs_offshore_floating/ard_system.yaml  |   5 +-
 .../inputs_offshore_monopile/ard_system.yaml  |   5 +-
 .../ard/api/inputs_onshore/ard_system.yaml    |   5 +-
 .../inputs_onshore/ard_system_bad_windio.yaml |   5 +-
 .../ard_system_multiobjective.yaml            |  99 ++++
 test/unit/ard/api/inputs_onshore/windio.yaml  |  34 ++
 test/unit/ard/api/test_interface_unit.py      |   5 +-
 test/unit/ard/api/test_multiobjective.py      |  84 +++
 18 files changed, 584 insertions(+), 413 deletions(-)
 create mode 100644 test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
 create mode 100644 test/unit/ard/api/inputs_onshore/windio.yaml
 create mode 100644 test/unit/ard/api/test_multiobjective.py

diff --git a/.gitignore b/.gitignore
index 090f2011..20e9a213 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,8 @@
 ### ARD DEVELOPMENT IGNORES 
 
 .vscode
-case_files/
+case_files
+ard_prob_out
 
 ### MACOS DEFAULT IGNORES
 
diff --git a/ard/api/interface.py b/ard/api/interface.py
index dd2ce4f9..22b7d60c 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -254,11 +254,13 @@ def set_up_system_recursive(
                     prob.model.add_constraint(constraint_name, **constraint_data)
 
             # set objective
-            if "objective" in analysis_options:
-                prob.model.add_objective(
-                    analysis_options["objective"]["name"],
-                    **analysis_options["objective"]["options"],
-                )
+            if "objectives" in analysis_options:
+                for obj_name, obj_options in analysis_options["objectives"].items():
+                    obj_options = {} if (obj_options is None) else obj_options
+                    prob.model.add_objective(
+                        obj_name,
+                        **obj_options,
+                    )
 
             # Set up the recorder if specified in the input dictionary
             if "recorder" in analysis_options:
@@ -268,6 +270,8 @@ def set_up_system_recursive(
                     prob.add_recorder(recorder)
                     prob.driver.add_recorder(recorder)
 
+        # TODO! THIS IS NECESSARY FOR SOME REASON WHEN RUNNING FREE
+        # OPTIMIZATIONS. THIS SHOULDN'T BE NEEDED...
         prob.model.set_input_defaults(
             "x_turbines",
             # input_dict["modeling_options"]["windIO_plant"]["wind_farm"]["layouts"]["coordinates"]["x"],
@@ -279,6 +283,7 @@ def set_up_system_recursive(
             units="m",
         )
 
+        # setup the openmdao problem
         prob.setup()
 
     return prob
diff --git a/assets/logomaker/inputs/ard_system.yaml b/assets/logomaker/inputs/ard_system.yaml
index c744e15c..6ae83c0c 100644
--- a/assets/logomaker/inputs/ard_system.yaml
+++ b/assets/logomaker/inputs/ard_system.yaml
@@ -75,9 +75,8 @@ analysis_options:
       units: "m"
       upper: 0.0
       scaler: 0.004128137384  # 1/D_rotor
-  objective:
-    name: AEP_farm
-    options:
+  objectives:
+    AEP_farm:
       scaler: -1.0e-9
   recorder:
     filepath: opt_results.sql
\ No newline at end of file
diff --git a/examples/01_onshore/inputs/ard_system.yaml b/examples/01_onshore/inputs/ard_system.yaml
index 81183d72..9adf5102 100644
--- a/examples/01_onshore/inputs/ard_system.yaml
+++ b/examples/01_onshore/inputs/ard_system.yaml
@@ -78,9 +78,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: km
       lower: 0.552
-  objective:
-    name: financese.lcoe
-    options:
+  objectives:
+    financese.lcoe:
       scaler: 1.0
   recorder:
     filepath: cases.sql
diff --git a/examples/02_offshore_fixed/inputs/ard_system.yaml b/examples/02_offshore_fixed/inputs/ard_system.yaml
index 7ab06378..779ed0e6 100644
--- a/examples/02_offshore_fixed/inputs/ard_system.yaml
+++ b/examples/02_offshore_fixed/inputs/ard_system.yaml
@@ -105,9 +105,8 @@ analysis_options:
       units: m
       lower: 852.0
       scaler: 0.0005  # 1/(7D)
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       units: km
       scaler: 0.05
   recorder:
diff --git a/examples/02_offshore_fixed/optimization_demo.ipynb b/examples/02_offshore_fixed/optimization_demo.ipynb
index 5277135c..1540c716 100644
--- a/examples/02_offshore_fixed/optimization_demo.ipynb
+++ b/examples/02_offshore_fixed/optimization_demo.ipynb
@@ -63,13 +63,6 @@
    "id": "22d078e2",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mturbine_type has been changed without specifying a new reference_wind_height. reference_wind_height remains 90.00 m. Consider calling `FlorisModel.assign_hub_height_to_ref_height` to update the reference wind height to the turbine hub height.\u001b[0m\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -257,7 +250,23 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([7.]),\n",
       " 'spacing_secondary': array([7.])}\n",
-      "\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
+      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
+      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
+      "invalid value encountered in divide"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
       "Objectives\n",
       "{'collection.total_length_cables': array([47761.10752126])}\n",
       "\n"
@@ -278,118 +287,107 @@
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|2\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.00080387]),\n",
-      " 'angle_skew': array([-0.00104343]),\n",
-      " 'spacing_primary': array([6.97160497]),\n",
-      " 'spacing_secondary': array([6.94320903])}\n",
+      "{'angle_orientation': array([-0.001023]),\n",
+      " 'angle_skew': array([-0.00180114]),\n",
+      " 'spacing_primary': array([6.95385903]),\n",
+      " 'spacing_secondary': array([6.96095497])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([47422.44976731])}\n",
+      "{'collection.total_length_cables': array([47468.82258446])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|3\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.02013307]),\n",
-      " 'angle_skew': array([-0.03367621]),\n",
-      " 'spacing_primary': array([6.85288012]),\n",
-      " 'spacing_secondary': array([6.59919383])}\n",
+      "{'angle_orientation': array([-0.01294036]),\n",
+      " 'angle_skew': array([-0.01076827]),\n",
+      " 'spacing_primary': array([6.72315013]),\n",
+      " 'spacing_secondary': array([6.76572615])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([45461.68266391])}\n",
+      "{'collection.total_length_cables': array([46007.37034942])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|4\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.13933268]),\n",
-      " 'angle_skew': array([-0.19339181]),\n",
-      " 'spacing_primary': array([6.25924076]),\n",
-      " 'spacing_secondary': array([4.87908646])}\n",
+      "{'angle_orientation': array([-0.07237704]),\n",
+      " 'angle_skew': array([-0.05906184]),\n",
+      " 'spacing_primary': array([5.56961525]),\n",
+      " 'spacing_secondary': array([5.78958899])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([35658.12664397])}\n",
+      "{'collection.total_length_cables': array([38700.47433567])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|5\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.27132002]),\n",
-      " 'angle_skew': array([-0.36507551]),\n",
-      " 'spacing_primary': array([5.59352781]),\n",
-      " 'spacing_secondary': array([3.00004])}\n",
+      "{'angle_orientation': array([-0.19957183]),\n",
+      " 'angle_skew': array([-0.16358824]),\n",
+      " 'spacing_primary': array([3.00018829]),\n",
+      " 'spacing_secondary': array([3.57836429])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([24902.77860916])}\n",
+      "{'collection.total_length_cables': array([21492.73960076])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|6\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.26746584]),\n",
-      " 'angle_skew': array([-0.36438297]),\n",
-      " 'spacing_primary': array([5.57165881]),\n",
-      " 'spacing_secondary': array([3.])}\n",
+      "{'angle_orientation': array([-0.19957183]),\n",
+      " 'angle_skew': array([-0.16358825]),\n",
+      " 'spacing_primary': array([3.]),\n",
+      " 'spacing_secondary': array([3.54266927])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([24865.97107427])}\n",
+      "{'collection.total_length_cables': array([21431.05302072])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|7\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.238704]),\n",
-      " 'angle_skew': array([-0.26296628]),\n",
-      " 'spacing_primary': array([5.45852978]),\n",
-      " 'spacing_secondary': array([3.])}\n",
+      "{'angle_orientation': array([-0.19066606]),\n",
+      " 'angle_skew': array([-0.16267477]),\n",
+      " 'spacing_primary': array([3.00000553]),\n",
+      " 'spacing_secondary': array([3.36495284])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([24675.47645605])}\n",
+      "{'collection.total_length_cables': array([21128.76760916])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|8\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.09214593]),\n",
-      " 'angle_skew': array([0.24250766]),\n",
-      " 'spacing_primary': array([4.89375834]),\n",
-      " 'spacing_secondary': array([3.00012142])}\n",
+      "{'angle_orientation': array([-0.17219214]),\n",
+      " 'angle_skew': array([-0.15177619]),\n",
+      " 'spacing_primary': array([3.00001855]),\n",
+      " 'spacing_secondary': array([3.])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([23728.27195423])}\n",
+      "{'collection.total_length_cables': array([20508.21747482])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|9\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.25195306]),\n",
-      " 'angle_skew': array([0.24250766]),\n",
-      " 'spacing_primary': array([3.55272138]),\n",
-      " 'spacing_secondary': array([3.00007768])}\n",
+      "{'angle_orientation': array([-0.17215351]),\n",
+      " 'angle_skew': array([-0.15179557]),\n",
+      " 'spacing_primary': array([3.00000001]),\n",
+      " 'spacing_secondary': array([3.])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([21449.28234797])}\n",
+      "{'collection.total_length_cables': array([20508.1227013])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|10\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.35629992]),\n",
-      " 'angle_skew': array([0.15825882]),\n",
-      " 'spacing_primary': array([3.00003157]),\n",
-      " 'spacing_secondary': array([3.00001001])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.57745996])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|11\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.35830145]),\n",
-      " 'angle_skew': array([0.15662531]),\n",
-      " 'spacing_primary': array([3.00000051]),\n",
+      "{'angle_orientation': array([-0.17215348]),\n",
+      " 'angle_skew': array([-0.15179561]),\n",
+      " 'spacing_primary': array([3.]),\n",
       " 'spacing_secondary': array([3.])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.42919773])}\n",
+      "{'collection.total_length_cables': array([20508.12264852])}\n",
       "\n",
       "Iteration limit reached    (Exit mode 9)\n",
-      "            Current function value: 1.0253714598865464\n",
+      "            Current function value: 1.025406132426226\n",
       "            Iterations: 10\n",
-      "            Function evaluations: 11\n",
-      "            Gradient evaluations: 11\n",
+      "            Function evaluations: 10\n",
+      "            Gradient evaluations: 10\n",
       "Optimization FAILED.\n",
       "Iteration limit reached\n",
       "-----------------------------------\n",
@@ -397,14 +395,14 @@
       "\n",
       "RESULTS (opt):\n",
       "\n",
-      "{'AEP_val': 2071.4571935884464,\n",
-      " 'BOS_val': 1250.5550001803392,\n",
+      "{'AEP_val': 2070.8153157802635,\n",
+      " 'BOS_val': 1250.5549973623238,\n",
       " 'CapEx_val': 768.4437570425,\n",
-      " 'LCOE_val': 102.3071620536793,\n",
+      " 'LCOE_val': 102.33887346951097,\n",
       " 'OpEx_val': 60.50000000000001,\n",
-      " 'area_tight': 11.614465966740871,\n",
-      " 'coll_length': 20.507429197730925,\n",
-      " 'turbine_spacing': 0.8520001442738311}\n",
+      " 'area_tight': 11.614464,\n",
+      " 'coll_length': 20.50812264852452,\n",
+      " 'turbine_spacing': 0.8519999999999999}\n",
       "\n",
       "\n",
       "\n"
@@ -412,7 +410,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArMAAAIjCAYAAAAQgZNYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbXNJREFUeJzt3Qd0VNXWwPGdHgJJ6D10pDdFFBFBaTYs2BuI5angE0EsqAhYQPieXZFnxYKKBVB5inQp0ptIr4beAmmUhGS+tU+YMY1kJky7M//fWpeZuVPumdwk7OzZZ58Qm81mEwAAAMCCQn09AAAAAKCkCGYBAABgWQSzAAAAsCyCWQAAAFgWwSwAAAAsi2AWAAAAlkUwCwAAAMsimAUAAIBlEcwCAADAsghmAQB+afjw4RISEuLrYQDwcwSzACxl27Zt8tBDD0m9evUkOjpa4uLipEOHDvLWW2/JiRMnfD08OOHee+81Qap903PYqlUree211+TUqVNuOcbYsWNl/PjxbnktAP4t3NcDAABn/e9//5NbbrlFoqKipHfv3tK8eXPJyMiQBQsWyJNPPinr1q2TDz74wNfDhBP0HH700Ufm+rFjx+SHH36QwYMHy7Jly+Sbb75xSzBbsWJFEzgDCGwEswAsYceOHXL77bdL7dq1Zfbs2VKtWjXHff3795etW7eaYNfKTp48KZGRkRIaGvgfmoWHh8vdd9/tuN2vXz+56KKLZOLEifL6669L9erVfTo+ANYR+L8xAQSEMWPGSFpamnz88cd5Alm7Bg0ayIABAxy3T58+LS+99JLUr1/fZAHr1Kkjzz77bIGPsXX/tddea7K77dq1M6ULWsLw+eefOx6zfPly83H4Z599VuC4v/32m7lv6tSpjn179uyR++67T6pUqWKO3axZM/nkk0/yPG/u3LnmeZqFfP7556VGjRoSExMjKSkp5v7vvvtOmjZtasajGejJkyebLKOON7fs7Gx58803zTH0sXpMLcM4evSoy+/TTjOlAwcONM/R8desWdNkwg8fPux4jH4dhw0bZr7u+piEhAR56qmnSlwmoAF8586dzfWdO3ee9XHOnFfdp1n633//3VHKYH9tAAHIBgAWUKNGDVu9evWcfnyfPn1s+ivu5ptvtr333nu23r17m9s33HBDnsfVrl3b1qhRI1uVKlVszz77rO3dd9+1nX/++baQkBDbX3/95XicHvvqq68ucJy+ffvaypUrZ8vIyDC39+/fb6tZs6YtISHB9uKLL9ref/9923XXXWeO/cYbbzieN2fOHLOvadOmttatW9tef/1126hRo2zp6em2qVOnmuO3bNnS7B86dKg5RvPmzc14c3vggQds4eHhtgcffNA2btw429NPP20rXbq07cILL3SMyZX3mZqaao4TFhZmXlPH/9JLL5nXW7VqlXlMVlaWrXv37raYmBjb448/bvvvf/9re/TRR804rr/+eqfOjY4xvxtvvNF8TTZu3GhuDxs2zNx29bxOnjzZnIPGjRvbvvjiC7NNnz692HEBsCaCWQB+Lzk52QQszgRKavXq1ebxGujlNnjwYLN/9uzZeYI83Tdv3jzHvoMHD9qioqJsTzzxhGPfkCFDbBEREbakpCTHvlOnTtnKli1ru++++xz77r//flu1atVshw8fznPs22+/3RYfH287fvx4nmBWg2T7PrsWLVqYYEwDS7u5c+eax+cOZufPn2/2TZgwIc/zp02bVmC/s+/zhRdeMI+bNGlSga9rdna2udTgMDQ01Bw/Nw2m9bkLFy60ORPMHjp0yGxbt261jRw50hHA2+UPZl05r82aNbN16tSpyHEACAyUGQDwe/aP3mNjY516/C+//GIuBw0alGf/E088YS7z19bqx/kdO3Z03K5UqZI0atRItm/f7th32223SWZmpkyaNMmxb/r06eYjeb1PaYJAJzL17NnTXNeP5e1bjx49JDk5WVauXJnn2H369JFSpUo5bu/du1fWrl1rPtYvU6aMY3+nTp2kRYsWeZ6rpQjx8fHSrVu3PMe64IILzHPnzJnj8vvU8WtngRtvvLHA19XeJkuP26RJE2ncuHGe415xxRXm/vzHLUx6ero5vm5aqqClAu3btzflFO46rwCCAxPAAPg9bd2kUlNTnXr833//bWowNUjKrWrVqlK2bFlzf261atUq8BrlypXLU3eqAZ4GbzpB6f777zf79LrOmLcHcYcOHTLBrXZUOFtXhYMHD+a5Xbdu3QJjV/nHbt+XOxjesmWLCZArV67s1LGceZ/a+uymm24q9PVyH3fDhg0mEHXmuIXRmt2ff/7ZXNfaV/06aG2uO88rgOBAMAvAEsGszm7/66+/XHqesw33w8LCCt2v2dXcNAP7yiuvmCykZol/+uknueOOO8zMfPtkLKWz9DXjWpiWLVvmuZ07K+sqPZ4GshMmTCj0/vzBprPv05njapZYuw4URieDFUfH0rVrVykJFlIAkBvBLABL0Jn4mu1ctGiR+Ti6KNq+SwMuzSDqx+F2Bw4cMJlTvb8kNJgdMWKE+SheuwZo+YO2C8sdPGqQm5WVVeJAzT42bTWWX/59OqN/5syZZtGIcwmK879mcX806GPWrFkjXbp08Wpg6cp5JeAFggc1swAsQds+lS5dWh544AETvOSnH4/rKmDq6quvNpfasio3eybxmmuuKdEYNIDSjKSWF+imLcIuu+yyPNlG/Yheg93CAkItQyiOZqC1FZe2zNJWZHbaZkpraXO79dZbTeCsraoKa2GlAZ6rdPwaqBZWu2rP4Opxtf3Yhx9+WOAxugqb1sN6givnVb9XSvL+AVgPmVkAlqDZwK+++spkRzWozL0C2B9//GEmJdlXe9L6Vv2YXzO5GtDo5KmlS5eaPrE33HCDXH755SUehx7/hRdeMDWfWjubf4GDV1991UyA0gUAHnzwQTPpKikpydS6ahZVrxdn5MiRcv3115uMa9++fU1N67vvvmveb+4AV9+X9pQdNWqUrF69Wrp37y4REREmc6lfDw3ub775Zpfen66k9v3335uV1rRXrk4m0zFrScW4cePM1/aee+6Rb7/9Vh5++GHzXnWcGlRv3LjR7Nfeu23bthV3c+W86rjff/99efnll02NrZZj2GubAQQYX7dTAABXbN682fQ/rVOnji0yMtIWGxtr69Chg+2dd96xnTx50vG4zMxM24gRI2x169Y1LbW076u218r9GHvLqmuuuabAcbStU2GtnbZs2WLaQOm2YMGCQsd44MABW//+/c0x9dhVq1a1denSxfbBBx84HmNvzfXdd98V+hrffPON6ZOqrbO07+tPP/1ku+mmm8y+/PR1L7jgAlupUqXM10Nbez311FO2vXv3luh9HjlyxPSN1d6++jXWNmHaTit3uzHtYTt69GjTAkvHqH1wdQz6NddWaiXpM5tfYX1mnT2v2u9X369+PfQ1aNMFBK4Q/cfXATUAoHitW7c2dbkzZszw9VAAwG9QMwsAfkb72WrNa/7lb7WWlWVZASAvMrMA4Gd27txpuiFoiy+dEKa1qFqvqgsk6MSyChUq+HqIAOA3mAAGAH5GFzLQCUwfffSR6YCgM/N1pr5OLiOQBYC8yMwCAADAsqiZBQAAgGURzAIAAMCygq5mVpdC3Lt3r1lykuUOAQAA/I9WwaampppJsPkXp5FgD2Y1kE1ISPD1MAAAAFCMXbt2Sc2aNYt8TNAFs5qRtX9x4uLivNYzcvr06Y6lJmEtnD/r4xxaH+fQ2jh/1pfp5XOYkpJiko/2uK0oQRfM2ksLNJD1ZjAbExNjjscPsfVw/qyPc2h9nENr4/xZX6aPzqEzJaFMAAMAAIBlEcwCAADAsghmAQAAYFlBVzMLAEAwtjk6ffq0ZGVl+azeMjw8XE6ePOmzMcD/zqHW3oaFhZ3z6xDMAgAQwDIyMmTfvn1y/PhxnwbTVatWNZ2E6PFuTTYPnEN9HW27VaZMmXN6HYJZAAACeKGgHTt2mOyXNp+PjIz0STCp40hLSzNBS3EN8OGfst18DjU4PnTokOzevVsaNmx4ThlaglkAAAI4K6tBiPbr1LZKvqJj0LFER0cTzFpUtgfOYaVKlWTnzp2mhOFcglm+owAACHAEkPBH7vqUgO9uAAAAWBbBLAAAACzLp8HsqFGj5MILLzTr7lauXFluuOEG2bRpk9PP/+abb0yKWp8HAAA8JyvbJou2HZEfV+8xl3rbX9SpU0fefPPNc37MuRo/fryULVtWvOGee+6RkSNHij+7/fbb5bXXXgvsYPb333+X/v37y+LFi2XGjBmmALh79+6Snp5e7HO1YHjw4MHSsWNHr4wVAIBgNe2vfXLp6Nlyx4eLZcA3q82l3tb9nqRtoO677z5HJ4batWvLgAED5MiRIy6/1rJly+Rf//qX28ZWWHB82223yebNm8XT1qxZI7/88os89thjjn2dO3eWxx9/vMjnzZkzR66++mqpUKGCmRDYtGlTeeKJJ2TPnj2Ox2gP2TfeeENatGhhJnuVK1dOrrrqKlm4cGGBwF0Tivk3fY7d888/L6+88ookJydLwAaz06ZNk3vvvVeaNWsmrVq1Ml+YxMREWbFiRZHP0y/0XXfdJSNGjJB69ep5bbwAAAQbDVgf+XKl7Es+mWf//uSTZr+nAtrt27dL27ZtZcuWLfL111/L1q1bZdy4cTJr1ixp3769JCUluTxz3tMdHUqVKmU+afa0d955R2655RaX+rP+97//la5du5pesT/88IOsX7/efD010LRnT7VdlmZTX3zxRfNHw4YNG2Tu3LmmG8YVV1wh//vf//K8ZlxcnOlhnHv7+++/Hfc3b95c6tevL19++aV4kl+15rJH7uXLly/ycfpF1m+W+++/X+bPn1/kY0+dOmU2u5SUFHOpWWDdPE0/hlm87ZCsOBwi8VsOysX1K0lYaOA0jNb3t/zvo3Iw9ZRUjo2StrXLBdT7U/bvE298v8AzOIfWxzksGf16aYCibZV0U3r7RGaW07/jh/20TgorKNB9+tt++E/rpH298kX+7tdj2jf7OIrTr18/k43VxJcGiUob7GvyS/uSPvvsszJ27Ng8/79rIPbzzz+bj/qHDBliXsNOk18aoOmmjh07Jk8++aT89NNPJk7QwFmDOn19O32tl19+WdauXWsCx0svvVQmTZpkAjsN2gYOHGg287XKyjJJuUGDBplAWzO0TZo0kXXr1knjxo0dr6nZ3Pfee88E6eqvv/6Sp556ShYsWCClS5eWbt26yeuvvy4VK1Ys/JxkZcn3338vX3zxRYGvpe0sX1/t5apZ3H//+9/mte1q1apl3pN+LfR5EydONK89ZcoU6dmzp+NxGvQePnzYvIbu16+FPl4zsYUF77nHcO2115qy0EceeaTQx+mYC2vN5crPut8Es/qGND3eoUMHE8mfjZ7sjz/+WFavXu10Xa5mcPObPn26x/9CW3MkRCbtDJVjGfoDHiafb1ktZSNt0qtOtrSq4D+1Ru55fzkC6f3lp6UwsDbOofVxDl2jy49qJk6b3WuPUHUiI0vav77YLa+vv+n3p5ySVi/OLPaxiwZdLCGpqU697tGjR83/0/oxdf7kk/7frVlJDbz0/3gNqDSG+M9//mMCSy1BnD17tokpatSoIZdffrl5nj5Gl2K1J7Vuuukm85H4t99+azKMGohq5nL58uXmo/XffvvNfAqsH8O/++675uun33/6/E8//dQEgfrpcu/evc3r6X59fQ3O9Lp+3du0aWMe+9xzzznGr0For169zGM0idelSxdT/6qJOn3+8OHD5eabbzZBdmH+/PNP87xGjRo53ovS5Yp1jLn32WlmVO97+OGHC71fW7fpfh1bgwYNpFOnTgUe99BDD8nkyZNNgH/NNdfkea9F0U/ftbZXF0iIiorKc5+O6cSJEzJv3jwz/txcWbHOb4JZrZ3Vv040WD2b1NRUc8I//PDDs/7Fkp/+ZaZ/JdnpF13T5Vqbq9+8nvLbugPy6aI1Bf6aTc4IkU83h8k7t7eSHs2qiFUF+vvLTX+J6i8w/WtZ15GG9XAOrY9zWDIacGjdqWbS7LWM4Rl5gwZv0gnfzvQW1Y+3NVBq3bp1of9Xt2zZUj777DOTUdXMoAZjl1xyiQwbNszcf/7555uSxQ8++ECuv/56s08fo18DfT2NNVauXCn79+93BFgaeP76668miNXa2rfeesvUwGrAbKcJN6Wvod+HGotolthOX1/fn33MGrNoFnb06NHmtmZrNRk3YcIE8xgtF9DjaiBup0G11gbr2M4777wC710zpJrF1I/vc38tw8PDTSa7sK+Xfg/o/sJeLzddLU7raAt7jQsuuCDPa+l71ZhKs+W5aZCv9bx2Ghxr0KrBqZZ65P/+1Kz7ZZddlqfWVhUXJPtdMPvoo4/K1KlTTWSe/4uS27Zt28zEr9ypb3sqW0+idkLQk5ubfpPm/0tA6Tehp34h6scyr/y66awfy6ihP603P1ihFvxIPjvbJs//tL7Ij530/V/VskZAlRx48nsG3sE5tD7OoWv0I2kNeHL+v8mZJlM6KkLWv9jDqecv3ZEk9366rNjHje97obSre/YSQf2/OvNEumMsxbE/5myPtwdxud+XBrO5H6u39SP93Pvsr6dlA5qtzh9caZZQAzp9jAadDz74YJHjzT8++3X75R133GFKGZYuXSoXX3yxqf3VQFsDRnuWVWtSCwsedRy5yxPsNIDXuKawFbNCivj6Ovu1zz3+/M/P/Tq66R8n+kdBbhqc5n6+lk7YA9f8r6u39fUK+7l25efcp8Gs/tWl9RuattaTWbdu3SIfrydVvwFz048gNGOrf0FpxtUf6A9//kL5/I4ez5R+X62SQKQBrb7/dq/MkGplS0m5mEgpX/rMptfLnLm07ysdKWVjIv0y8NU/TJbsSDI1zxV2JEn7BpX9cpwA4CwNHmIinfvvv2PDSlItPtpM9iosgaG/DavGR5vHFfW7UYPZlJPO/+7UbJ6OUzO0N954Y4H7db+WAuQPRp2lgWy1atVM7JGfvbWWvU73XGipgdbXfvXVVyaY1cvctaM6Dk3Q2TO3uen4CqPZYM1yarZTM7HO0IysliboBK2zva79cfq1LYx9f+5MtAajeq6KYp+oV9Jz5ffBrJYW6In98ccfTXSvKXUVHx/v+CbSWhStedE0v6ag89fT2r/piqqz9baDqUUHsnZ1K5aWCqWd+0b0J0fSM2TH4eLbpx1JzzSbM/QPvrKlIqRc6YKBrn3T+/TrpcFxhTKRUioizG1L4RVGZ+iO+Hn9mT9MtOZ5ufmlPqxnU7my+dl/GQBAoNAAVX/nadcC/W2bO6C1//bV+939R762jtKSEp3gpXWwuQNLjRX0Y3qND3L/H6BtPnPT2zoBqzCaHdXX0U91tcVWYbSUQTsn9O3bt9D7NZDUzHdxtO5WJ3hpllY7NOgktdzj0M4COgYdizO09EJpNwL79eJoDe4zzzwjY8aMMW238tMJYBpP6djuvPNOUxeb+1NwpRPHdIK+nhdXaAmpfurubHmo5YLZ999/39EbLTctltaiaqWtuqy2pnTl2Lx1H2cz8sYW0r5+BbEabZatPQaL89INzaVG2WhJSs+UpPRT5vJoeoYJho8ez5Ck9Jwt+YTOts3JVuu2XYoPlFVUeGhOcJs74NVAN3fgm+tS73P2F669FU3+TIS9Fc37d59PQAsgKOjvOv2d988f9zmqeviPe510paUCPXr0MB0F9NNb7QygH9trkkv7l+amfVA1WNOFlLS++rvvvivQSspOJ3ppey99rD5HM5J79+41j9dMsHY20PpbnZyl5Ysa5OkEJa0Fffrpp81raACq5ZF6n37sf7ZgTSd7aTZWN52Mpj1zcyf1dB6QBroa8GqwqC3IdPb/Rx99VGgpgWY4NQjWut/8weyhQ4cKTJDXTKx+cq1BrJZ1ai2q/iGg49cuB59//rmpqdZODvpe9OvWp08f+b//+z/z/vXxWverAa7W89rLBuyfsNsTkbnZ65iVdp3SeUqe5PMyg+IU9hFAbvqF9TdaN+TMxzJF1Rf5M2ff353tajkVPGZmZcux4xrw/hPgJmmwm5Y36M29ZWRly6nT2bI3+aTZnKF/wMeXinBkfgsEvGdKIOKjI2Toj0W3otFf6t2aVqXkAEBQ0IBVf+dpGZ1++qhJG/2/wJO/A/XjbO0soEHlrbfeaj6u1o/tNQDVffnbeGrXAX28djDSGlTNJGogXBjN6Gpgql0GNPOqQaC+tk5EqlKliiPRpoHdSy+9JK+++qp5Tb3fTrsP6Ax/DXa1jvVsMY1+8qxZTu2a8Mknn+S5TwNbDcI1QNaAT19HJ39deeWVRSbyHnjgAROEanCam37arVtuOn4tydQ2ZRq062QzDdi1PlgDWm2dZZ8or18XHafWGmvwq8/RT8U18NcOEbqQQm4a6BZWtqDlDPr11DpZbfOl7dU8KcTmTEQZQPQLr2UMWjviyW4G9syenOVjGatn9nz5/vRbNj0j658sb65LexBsLnPdp9lfd/v6wYstmVkP1pnw+h+XrnzD5CFr4hyWjAYTOpFIs5r5Z4t7k6mZTUkx/+/66tNWDbo0sNNA0Oo0ENXWXNqerH379n57DvUTeJ0XpW3WXP3+dCVe84tuBoHIVx/LBMP7078cy0SFmy2hvHO9gk9nZZ8pY8iQI2cyvo4A+Mxmv2/vsRNyzIng92CKcxlhAIDv6GQpzX4eOHDA9DwNBFpDrJlZbdPlz/QPT20/5mkEs174WGbR1oMyff4S6d7xooCaDe+Lj51KKjwsVCrFRplNqrinJvg/0zeZAPjGNjUlPoZMEQD4I+01qxlZXUTBW1lMb8g/38gfeSsLTjDrYRrYXVS3vBzZYDOX/hjonQt9P4H2UXtxNcF2u46ekOE/r5dRv26Ua1tWlzsvSpDza5XzaIcFAIBrNIjVDYHLWm0CAC+2olH5w9KQM9trt7SSEdc1k0ZVYs1EtB9W7pab3l8kV745X8Yv3CHJx1k/HgAAbyCYBYqoCdYa4Nz0tu6/6YKa0ueSOjLt8Y7ywyOXyM0X1JToiFDZdCDVZGvbjZwpg75dLct3JjnVtQMAPInfQwjk70vKDIBzqHnWkoILapcz29Brm8qUVXvkqyWJJqidtHKP2c6rUkbuaFdLelFbC8DL7J0fdBKUO1a0AtxJVzFThfXTdQXBLOCmmmftYavZ2t7ta8uqXcdMUDv1z72y+UCa6frw6q8b5ZqW1Uz/XQ1+qa0F4GkaJOjKTgcPHjS3Y2JifPK7R9s6aeCirZisthASPHMO9fW0v69+Tzq7+tnZEMwCbqb/UehEMN00W/vj6pxs7cb9ZGsBeJ82r1f2gNZXHydrb1TNDvOHvDXZPHAONSiuVavWOb8ewSzgQZqt7d2+jtxzcU629uslifJz/mxti2pyx0W1pC3ZWgAeoL9XdMEAXWJUF5/wBT2uLv2qK2ix6IU1ZXrgHEZGRroly0swC3g5W/t8/mztqj1ma1j5TLb2/BpSNibS10MGEIAlB+dam3guxz59+rRZ5Ylg1prC/PgcEswCPszWrtZs7dJE+XnNPtlyME1enLpeRk8jWwsAgLMIZgEf0SC1Ta1yZjPZ2lV7ZALZWgAAXEIwC/iBuOgIuad9Hbn7LNnaV+3Z2na15MI6ZGsBALAjmAX8OVu7eq+prd2wL0Umr9pjtgZnsrU3ka0FAIBgFvDrbO3FteXui2rJmt3JphPCT2v2ytaDafJS7tpasrUAgCBGMAv4OQ1SWyeUNdtz1zYpMlvbq00NKVeabC0AIHgQzAIBlq29unlVE9i2q1uebC0AIOARzAIWz9Y+nytbu35fikxZvdds9SuVPlNbW5NsLQAgYBHMAhYXGx1huiDcdVEt+VOztUtzsrXbDqXLy//bIGN+21RktjYr2yZLdyTJwdSTUjk22jwmLJSMLgDAGghmgQChQWqrhLJme+4a57K10/7aZ5bV3Zd80vE61eKjZVjPpnJl82o+fT8AADiDYBYI8Gzt2j3JJqjNk62dtklaJcTLsp1HCzx3f/JJeeTLlfL+3ecT0AIA/F6orwcAwLPZ2pY1y8qrN7WUJc92kVdubC7NqsdJRlZ2oYGssp251IytliAAAODPCGaBIMrW3nVRbZn670vllRuaF/lYDWG19EBraQEA8GcEs0AQZmvLRDtXYaSTwgAA8GcEs0AQ0q4F7nwcAAC+QjALBCFtv6VdC87WgEv36/36OAAA/BnBLBCEtI+stt9SZwto9X76zQIA/B3BLBCktO2Wtt+qGl+wlODJHo1oywUAsAT6zAJBTAPWbk2rOlYAm7xyt8zdfFiW7EiSfpf7enQAABSPzCwQ5LSUoH39CnJ96xry4vUtzO3fNx+SFX8X3ocWAAB/QjALwKFWhRi56fwa5vpbs7b4ejgAABSLYBZAHo9e3lDCQ0NkHtlZAIAFEMwCKCQ7W9NcJzsLAPB3BLMACuh/eQOyswAASyCYBVAA2VkAgFUQzAIoFNlZAIAVEMwCKBTZWQCAFRDMAjgrsrMAAH9HMAvAqezsmzM3+3o4AAAUQDALoEiPXpGTnZ2/5bCs+DvJ18MBACAPglkARUooHyM3X2DPzlI7CwDwLwSzAJyunSU7CwDwNwSzAIpFdhYA4K8IZgE4hewsAMAfEcwCcArZWQCAPyKYBVCi7OzynWRnAQC+RzALwKXs7C1tWRUMAOA/CGYBuKRfZ7KzAAD/QTALwCVkZwEA/oRgFoDLyM4CAPyFT4PZUaNGyYUXXiixsbFSuXJlueGGG2TTpk1FPufDDz+Ujh07Srly5czWtWtXWbp0qdfGDIDsLADAf/g0mP3999+lf//+snjxYpkxY4ZkZmZK9+7dJT09/azPmTt3rtxxxx0yZ84cWbRokSQkJJjn7Nmzx6tjB4Id2VkAgD8I9+XBp02bluf2+PHjTYZ2xYoVctlllxX6nAkTJuS5/dFHH8kPP/wgs2bNkt69e3t0vAAKZme/XrrL9J398oGLfD0kAEAQ8mkwm19ycrK5LF++vNPPOX78uMnonu05p06dMptdSkqKudTn6OYN9uN463hwL87f2f3r0jry3fLdsmDrYVm09aC0rV1O/BHn0Po4h9bG+bO+TC+fQ1eOE2Kz2WziB7Kzs+W6666TY8eOyYIFC5x+Xr9+/eS3336TdevWSXR0dIH7hw8fLiNGjCiw/6uvvpKYmJhzHjcQ7CZuC5U/DobKefHZ0r9ptq+HAwAIAJqsvPPOO02iMy4uzhrB7COPPCK//vqrCWRr1syZWFKcV199VcaMGWPqaFu2bOl0ZlbrbA8fPlzsF8edf11oTXC3bt0kIiLCK8eE+3D+irbn2Anp+sYCOZ1tk68fuNAvs7OcQ+vjHFob58/6Mr18DjVeq1ixolPBrF+UGTz66KMydepUmTdvntOB7H/+8x8TzM6cOfOsgayKiooyW356Irz9A+WLY8J9OH+Fq1MpQm5pmyBfL02U9+bukC8fqCz+inNofZxDa+P8WV+El86hK8fwaTcDTQprIDt58mSZPXu21K1b16nnaTb2pZdeMhPI2rZt6/FxAiha/8vrm84GWju7jM4GAAAv8mkwq225vvzyS1O/qr1m9+/fb7YTJ044HqMdCoYMGeK4PXr0aBk6dKh88sknUqdOHcdz0tLSfPQuANQsp50NEsz1t2bSdxYAECTB7Pvvv29qITp37izVqlVzbBMnTnQ8JjExUfbt25fnORkZGXLzzTfneY6WHQDwHbKzAABf8GnNrDNzz3RyV247d+704IgAnGt2Vmtn35y5WSY8cLGvhwQACAI+zcwCCLzsbERYiCzcekSW7iA7CwDwPIJZAJ6pnZ212dfDAQAEAYJZAG7VrzPZWQCA9xDMAnArsrMAAG8imAXgdmRnAQDeQjALwO3IzgIA/DqY1fV5d+3aJZs2bZKkJLIuAAoiOwsA8KtgNjU11SxY0KlTJ4mLizOrbzVp0kQqVaoktWvXlgcffFCWLVvm2dECsGR2VvvOAgDgs2D29ddfN8Hrp59+Kl27dpUpU6bI6tWrZfPmzbJo0SIZNmyYnD59Wrp37y5XXnmlbNnCcpYAtO9sA5Od/WPbEVmy/YivhwMACNYVwDTjOm/ePGnWrFmh97dr107uu+8+GTdunAl458+fLw0bNnT3WAFYTI2ypeTWtgkyYUmivDVri3xVr4KvhwQACMZg9uuvv3bqxaKiouThhx8+1zEBCCD9Lm8g3y7f5cjOXkRACwBwI7oZAPBKdlZpdhYAAK9nZu2OHTsmkydPNmUEf//9txw/ftxMAGvTpo306NFDLrnkErcODkBgIDsLAPBpZnbv3r3ywAMPSLVq1eTll1+WEydOSOvWraVLly5Ss2ZNmTNnjnTr1k2aNm0qEydO9NhgAVg/O/vmTLKzAAAvZ2Y189qnTx9ZsWKFCVgLowGudjl48803TQ/awYMHu3GYAAIlO7to+xFZvP2IXEx2FgDgrWB2/fr1UqFC0f/xlCpVSu644w6zHTlCCx4ABbOzt12YIF8uTpS3Zm6Ri/9FMAsA8FKZQXGB7Lk+HkBw6Nc5p++sPTsLAIBXJ4DlrqFdsGCBHDx4ULKzs/Pc99hjj53zoAAEpupkZwEAvg5mx48fLw899JBERkaaDGxISIjjPr1OMAuguOzsxGXUzgIAfNRndujQofLCCy9IcnKy7Ny5U3bs2OHYtm/f7qZhAQj07KzS7CwAAF4NZrW37O233y6hoay3AKBkqJ0FALiLyxHp/fffL999953bBgAguLOzb87c7OvhAACCqWZ21KhRcu2118q0adOkRYsWEhERkef+119/3Z3jAxDA2dlvl+2WxduTZNG2I9K+PrWzAAAvBbO//fabNGrUyNzOPwEMAFzJzn6x+G95a9ZmaV+/va+HBAAIhmD2tddek08++UTuvfdez4wIQNB4pHN909mA7CwAwGs1s1FRUdKhQ4cSHxAACu1sMIvaWQCAF4LZAQMGyDvvvFOCQwFA4dnZyLBQR3YWAACPlhksXbpUZs+eLVOnTpVmzZoVmAA2adIkV18SQBCjdhYA4NVgtmzZstKrV69zOigA5EbtLADAa8Hsp59+WuKDAUBx2VntO0t2FgDgLJbxAuAX+l2eUzu7ZAe1swAANwezV155pSxevLjYx6Wmpsro0aPlvffec2EIACBSLb6U3N6OVcEAAB4oM7jlllvkpptukvj4eOnZs6e0bdtWqlevLtHR0XL06FFZv369LFiwQH755Re55ppr5P/+7/9cHAYA5NTOfrN0lyM7S+0sAMAtwez9998vd999t3z33XcyceJE+eCDDyQ5Odmx6lfTpk2lR48esmzZMmnSpIkzLwkAZ83Ofr6I2lkAgJsngOliCRrQ6qY0mD1x4oRUqFChQHsuACgpsrMAAK9MANOSg6pVqxLIAnAramcBAK6gmwEAv10VTLOzf2w77OvhAAD8GMEsAD/Pzm4Rm83m6yEBAPwUwSwAv9SvcwOTnV2qtbPb6TsLACgcwSwAv1Q1PlruIDsLAHD3crZ2GRkZcvDgQcnOzs6zv1atWiV9SQDI45HODeTrpbsc2dlL6lf09ZAAAFbPzG7ZskU6duwopUqVktq1a0vdunXNVqdOHXMJAO5CdhYA4PbM7L333ivh4eEydepUqVatmlk0AQA8hewsAMCtwezq1atlxYoV0rhxY1efCgAlzs5+pquCzdgi7etV4I9oAEDJywx06drDh+n7CMC72dnI8FBZujNnVTAAAFwKZlNSUhzb6NGj5amnnpK5c+fKkSNH8tynGwB4Ijt7Z7ucyaXUzgIAXC4zKFu2bJ6P9fQ/ki5duuR5jO7Tx2RlZTnzkgDgkoc71ZevliY6srOXNKB2FgDgZDA7Z84cz48EAJzIzo7/Y6fJzravT+0sAMDJYLZTp06O64mJiZKQkFDgPxHNzO7atcv9IwSAM8jOAgDOeQKY9pI9dOhQgf1JSUn0mQXgUdTOAgDOOZi118bml5aWJtHR0S691qhRo+TCCy+U2NhYqVy5stxwww2yadOmYp/33XffmdZgerwWLVrIL7/84tJxAVg7O0tnAwCAy31mBw0aZC41kB06dKjExMQ47tNJX0uWLJHWrVuLK37//Xfp37+/CWhPnz4tzz77rHTv3l3Wr18vpUuXLvQ5f/zxh9xxxx0mEL722mvlq6++MkHwypUrpXnz5i4dH4C1a2ffmLmZ2lkACHJOB7OrVq1yZGbXrl0rkZGRjvv0eqtWrWTw4MEuHXzatGl5bo8fP95kaHVRhssuu6zQ57z11lty5ZVXypNPPmluv/TSSzJjxgx59913Zdy4cS4dH4A1PdI5p3Z22c6j8se2I9KB2lkACFpOB7P2jgZ9+/Y1AWVcXJzbB5OcnGwuy5cvf9bHLFq0yJEltuvRo4dMmTKl0MefOnXKbHb2XriZmZlm8wb7cbx1PLgX58//lC8VJre3rSmfL06UN2ZskgtrxRWZneUcWh/n0No4f9aX6eVz6MpxQmx+MoMiOztbrrvuOjl27JgsWLDgrI/TLPBnn31mSg3sxo4dKyNGjJADBw4UePzw4cPNfflpeULuUgkA1pKcIfLiyjA5bQuRfk2zpFG8X/wqAwC4wfHjx+XOO+80ic7iEqhOZ2btevXqVeh+zYrohKwGDRqYgzdq1Mil19Xa2b/++qvIQLYkhgwZkieTq5lZbS2mtbmeyC6f7a8LLYXo1q2bREREeOWYcB/On//aGrHRZGeXpleQx2+/8KzZWc6h9XEOrY3zZ32ZXj6Hrqwq63IwqwGgfqSvq4JdcMEFZp9OvtKMqgaIEydONEvezpo1Szp06ODUaz766KMydepUmTdvntSsWbPIx1atWrVABlZv6/7CREVFmS0/PRHe/oHyxTHhPpw//9P/iobyzfLdsvzvY7IsMaXY2lnOofVxDq2N82d9EV46h64cw+XWXBo0auZ1+/bt8sMPP5ht27Ztcvfdd0v9+vVlw4YN0qdPH3n66aeLfS2tcNBAdvLkyTJ79myn+tS2b9/eBMq56V8Kuh9AcKkSl7vv7Gb6zgJAEHI5mP3444/l8ccfl9DQf56q1//973/LBx98YD7m0wBVSwacKS348ssvTf2q9prdv3+/2U6cOOF4TO/evU2pgN2AAQNMF4TXXntNNm7caGpily9fbo4JIDg7G2jfWe1ssHArfWcBINi4HMxqP1gNIvPTfdpvVmntrDN9H99//31T2Nu5c2epVq2aY9NShdzL5+7bt89x+5JLLjHBrwbO2g7s+++/N2UP9JgFghPZWQAIbi7XzN5zzz1y//33mwUOdLEDtWzZMhk5cqTJotoXQ2jWrFmxr+XMfzpz584tsO+WW24xGwCofp3ry9dLE2X53znZ2Usb0ncWAIKFy8HsG2+8IVWqVJExY8Y4JmLp7YEDBzrqZHUimC5sAADeUFmzsxfVkk8X7jTZ2Q4NWBUMAIKFy2UGYWFh8txzz5mP/rWDgW56XTO1ep+qVatWsV0JAMCdHulUX6LCQx3ZWQBAcHA5mM3fpstbvVoBwJnsrKJ2FgCCh8vBrJYWaN1s9erVJTw83GRjc28A4CtkZwEg+LhcM3vvvfeaDgNDhw41nQeoSwPgL6idBYDg43Iwq8vNzp8/X1q3bu2ZEQHAOWZnv1qS09lgwdbD0rFhJV8PCQDgT2UGCQkJ1KIBsEjt7BZ+XwFAgHM5mH3zzTflmWeekZ07d3pmRADgptrZFWeyswCAwOVyMHvbbbeZhQzq169vlqAtX758ng0A/CE7e9dFtc31N2ZslsXbj8iKwyGyZEeSZGWTqQWAoK6Z1cwsAPi7hzvVk88X7ZSVicfknk9XaJds+XzLcqkWHy3DejaVK5tX8/UQAQC+CGb79OnjjuMCgEetTDwqpwvJwu5PPimPfLlS3r/7fAJaAAjWRRO2bdsmzz//vNxxxx1y8OBBs+/XX3+VdevWuXt8AOAyLSUY8fP6Qu+zh7d6PyUHABCEwezvv/8uLVq0kCVLlsikSZMkLS3N7F+zZo0MGzbME2MEAJcs3ZEk+5JPnvV+DWH1fn0cACDIglntZPDyyy/LjBkzJDIy0rH/iiuukMWLF7t7fADgsoOpJ936OABAAAWza9eulRtvvLHA/sqVK8vhw7TAAeB7lWOj3fo4AEAABbNly5aVffv2Fdi/atUqqVGjhrvGBQAl1q5uedO14GwL2ep+vV8fBwAIsmD29ttvl6efflr2799v1jzPzs6WhQsXyuDBg6V3796eGSUAuCAsNMS031L5A1r7bb1fHwcACLJgduTIkdK4cWOzrK1O/mratKlcdtllcskll8hzzz3nmVECgIu07Za236oan7eUQG/TlgsAgrjPrE76+vDDD+WFF14w9bMa0LZp00YaNmzomRECQAlpwNqtaVVZuPmA3P/Zcsm0hci4uy+QVgllfT00AICvglk7zczqZvfnn39K27ZtJSMjw11jA4BzpqUE7etXkPpxNtmYHCJ/7kkmmAWAYF80oTA2m02ysrLc9XIA4Fa1yuRcrtl1zNdDAQD4YzALAP6sdmzOal+rCWYBIKAQzAIICrVK5wSz2w6lScrJTF8PBwDg7ZrZlJSUIu9PTU11x3gAwCPiIkVqlI2WPcdOyl+7k+WSBhV9PSQAgDeDWV0sQfvKFlUzW9T9AOBrrWrGm2B21a5jBLMAEGzB7Jw5czw7EgDwsJY14+WXvw4wCQwAgjGY7dSpk2dHAgBeyMzaJ4HxaRIABAYmgAEIGk2rxZq+swdTT8n+lJO+Hg4AwA0IZgEEjZjIcDmvSqy5TqkBAAQGglkAQaX1mdW/dBIYAMD6CGYBBJXWCTl1s2RmASDIg9mtW7fKb7/9JidOnDC3dTIFAPi71gnlzOXa3cmSlc3vLQAIumD2yJEj0rVrVznvvPPk6quvln379pn9999/vzzxxBOeGCMAuE2DymUkJjJM0jOyZOvBNF8PBwDg7WB24MCBEh4eLomJiRITE+PYf9ttt8m0adPOdTwA4FHazaBFDUoNACBog9np06fL6NGjpWbNmnn2N2zYUP7++293jg0APKJ1LSaBAUDQBrPp6el5MrJ2SUlJEhUV5a5xAYDHtK6ZE8ySmQWAIAxmO3bsKJ9//rnjtq6gk52dLWPGjJHLL7/c3eMDAI9lZjcdSJUTGVm+Hg4AwBvL2dpp0NqlSxdZvny5ZGRkyFNPPSXr1q0zmdmFCxeey1gAwCuqxkVL5dgosxLYX3uT5cI65X09JACAtzKzzZs3l82bN8ull14q119/vSk76NWrl6xatUrq169f0nEAgNfoJ0qtziyesDqRUgMACKrMrIqPj5fnnnvO/aMBAC+uBDZj/QFZvZtgFgACPpj9888/nX7Bli1bnst4AMCry9oyCQwAgiCYbd26tflYrrhVvvQxWVlMpgDg/1rUjJeQEJHdR0/I4bRTUrEM3VgAIGCD2R07dnh+JADgRXHREVK/UhmzCphmZ7s0qeLrIQEAPBXM1q5duySvDQB+X2qgwexqglkACJ5uBmrTpk3y6KOPmhZduul13QcAVuLoaEDdLAAETzD7ww8/mPZcK1askFatWplt5cqVZp/eBwBWXAmsuDkBAIAAac2liyQMGTJEXnzxxTz7hw0bZu676aab3Dk+APCYxtViJTI8VFJOnpYdh9OlXqUyvh4SAMDTmdl9+/ZJ7969C+y/++67zX0AYBURYaHSvHqcub6GfrMAEBzBbOfOnWX+/PkF9i9YsEA6duzornEBgFe0TihnLlkJDAACuMzgp59+cly/7rrr5OmnnzY1sxdffLHZt3jxYvnuu+9kxIgRnhspAHhAq4R4c7l6d7KvhwIA8FQwe8MNNxTYN3bsWLPl1r9/f3n44YdLMg4A8OlKYBv2psip01kSFR7m6yEBANxdZpCdne3U5urqX/PmzZOePXtK9erVzephU6ZMKfY5EyZMMB0UYmJipFq1anLffffJkSNHXDouANjVKh8j5WIiJCMrWzbsS/X1cAAA3ugz6y7p6ekmMH3vvfecevzChQvN5LP7779f1q1bZ0obli5dKg8++KDHxwogMOkf0vZ+s9qiCwAQ4K257EHo77//LomJiZKRkZHnvscee8zp17nqqqvM5qxFixZJnTp1HMeoW7euPPTQQzJ69GgXRg8ABUsN5m46ZBZP6OPrwQAAPBvMrlq1Sq6++mo5fvy4CWrLly8vhw8fNh/7V65c2aVg1lXt27eXZ599Vn755RcTBB88eFC+//57M56zOXXqlNnsUlJSzGVmZqbZvMF+HG8dD+7F+Qv8c9i8Wk5/2dWJRznPfoqfQ2vj/FlfppfPoSvHCbG5uOyNtuY677zzZNy4cRIfHy9r1qyRiIgI02d2wIAB0qtXrxJ/1Dd58uRCJ5vlpqUFWid78uRJOX36tKm51ZXHdAyFGT58eKFdFr766isTgANAWqbIc8tz/rYfdeFpiSnRZ1YAAHfRpOmdd94pycnJEheX0w/cbcFs2bJlZcmSJdKoUSNzXT/6b9KkidnXp08f2bhxo8eC2fXr10vXrl1l4MCB0qNHD7NIw5NPPikXXnihfPzxx05nZhMSEkw2ubgvjjv/upgxY4Z069btrEE3/BfnLzjOYZc35kti0gn5pM/50rFBRa+PEUXj59DaOH/Wl+nlc6jxWsWKFZ0KZl3OP+gbCA3NmTemZQVaN6vBrGZpd+3aJZ40atQo6dChgwlgVcuWLaV06dJmsYaXX37ZdDfILyoqymyFvQ9v/0D54phwH85fYJ9DXTxBg9l1e9PkiiYFf5fAP/BzaG2cP+vz1jl05RguB7Nt2rSRZcuWScOGDaVTp07ywgsvmCznF198Ic2bNxdPp5zDw/MOOSwspyekiwlmACgwCeynNXvNJDAAQAC35ho5cqQjA/rKK69IuXLl5JFHHpFDhw7JBx984NJrpaWlyerVq82mduzYYa5rtlcNGTLEtOKy0/rYSZMmyfvvvy/bt283rbp0wlm7du1Mr1oAKClHe67dx/jjGAAsxOXMbNu2bR3Xtcxg2rRpJT748uXL5fLLL3fcHjRokLnU2tvx48ebmlh7YKvuvfdeSU1NlXfffVeeeOIJU7N7xRVX0JoLwDlrVj1OwkND5HBahuw+ekISyjNBFAACKpg9ceKEKfzV4DM2NrZAke7cuXPNpKzC6lOL6oxQVAZEA9r8/v3vf5sNANwpOiJMmlSLk7V7kk12lmAWAAKszEBLCN56660CgazSWWZvv/22fPTRR+4eHwB4TauEeHPJSmAAEIDB7IQJE+Txxx8/6/1632effeaucQGA12lHA8UkMAAIwGB2y5Yt0qpVq7Per22y9DEAYFWtz2RmtdTgdFa2r4cDAHBnMKurbWnHgrPR+/QxAGBV9SqWkdiocDmZmS2bDqT6ejgAAHcGs82aNZOZM2ee9f7p06ebxwCAVYWGhkhLR91ssq+HAwBwZzB73333yUsvvSRTp04tcN/PP/9ses7qYwDAylrVPNNvlrpZAAis1lz/+te/ZN68eXLddddJ48aNpVGjRmb/xo0bZfPmzXLrrbeaxwCA1VcCU0wCA4AAXAHsyy+/lG+++UbOO+88E8Bu2rTJBLVff/212QAgUILZzQdTJe0U8wAAIOBWANMMrG4AEIgqx0VL9fho2Zt8UtbuTpb29Sv4ekgAAHdlZgEgGLQ6k53VlcAAAP6NYBYAzhbMUjcLAH6PYBYA8mESGABYB8EsAOTToka8hIaI7Es+KQdSTvp6OACAIhDMAkA+paPC5bwqseY62VkACIBuBr169XL6BSdNmnQu4wEAv1k8YeP+VFM326NZVV8PBwBwLsFsfHzO8o4AEEyTwCYu30VmFgACIZj99NNPPT8SAPDDSWB/7k6W7GybhGoRLQDA71AzCwCFOK9KGSkVEWZWAdt+OM3XwwEAuGsFMPX999/Lt99+K4mJiZKRkZHnvpUrV5bkJQHAr4SHhZquBkt3JsmqxGPSoHLOhDAAgMUzs2+//bb07dtXqlSpIqtWrZJ27dpJhQoVZPv27XLVVVd5ZpQA4AOtEnLmC7ASGAAEUDA7duxY+eCDD+Sdd96RyMhIeeqpp2TGjBny2GOPSXJysmdGCQA+0DqhnLlkEhgABFAwq6UFl1xyibleqlQpSU1NNdfvuece+frrr90/QgDwcWZ2475UOZmZ5evhAADcEcxWrVpVkpKSzPVatWrJ4sWLzfUdO3aIzWZz9eUAwG/VKFtKKpaJlNPZNlm3N8XXwwEAuCOYveKKK+Snn34y17V2duDAgdKtWze57bbb5MYbb3T15QDAb4WEhDhadFFqAAAB0s1A62Wzs7PN9f79+5vJX3/88Ydcd9118tBDD3lijADg05XAZm44aFYCAwAEQDC7e/duSUhIcNy+/fbbzaYlBrt27TKlBwAQKFrXIjMLAAFVZlC3bl05dOhQgf1aR6v3AUAgaVkjJ5hNTDouSel5+2oDACwYzGoGVuvI8ktLS5Po6Gh3jQsA/EJ8TITUq1jaXKffLABYuMxg0KBB5lID2aFDh0pMTIzjvqysLFmyZIm0bt3aM6MEAB/SSWDbD6fL6sRjcnmjyr4eDgCgJMGsrvZlz8yuXbvWLJhgp9dbtWolgwcPdvblAMAyWiWUlUmr9pCZBQArB7Nz5sxxtON66623JC4uzpPjAgC/YW/PpR0NzlZqBQCwSM3sp59+6ghktbOBbgAQyBpXi5XIsFA5ejzTTAQDAFg4mNUesy+++KLEx8dL7dq1zVa2bFl56aWXHP1nASCQRIWHSZPqOX/E06ILACzeZ/a5556Tjz/+WF599VXp0KGD2bdgwQIZPny4nDx5Ul555RVPjBMAfKpNQllTZqDB7PWta/h6OACAkgazn332mXz00UdmxS+7li1bSo0aNaRfv34EswACUquEeHPJSmAAYPEyA10coXHjxgX26z69DwACUeuEcubyr70pknGakioAsGwwqy243n333QL7dZ/eBwCBqE6FGImLDjeB7Kb9qb4eDgDA1TKDevXqybJly2TMmDFyzTXXyMyZM6V9+/bmvkWLFsmuXbvkl19+cfblAMBStB2X9pudv+WwrN51VFrUzCk7AABYJDO7c+dOs9JXp06dZNOmTXLjjTfKsWPHzNarVy+zr2PHjp4dLQD4eBKYWr0r2ddDAQCUdAKY0sleTPQCEGw0M6tYCQwALBrM/vbbb6a/bFFydzkAgEAMZrcdSpOUk5kSFx3h6yEBQNBzKZjt06dPsTVlWooAAIGoYpkoqVmulOw+ekLW7k6WDg0q+npIABD0XOpmsH//frPK19k2AlkAga61o26WUgMAsFQwq1lXAAh2BLMAYNFg1mazeXYkAGChulkNZvm9CAAWCma1XrZUqVKeHQ0A+Lnm1eMlLDREDqWekn3JJ309HAAIek4Fs+np6fLpp59KbGysOPt4AAhEpSLDpFGVnN+Fayg1AABrBLMNGjSQV199Vfbt23fWx+jHbTNmzJCrrrpK3n77bXeOEQD8Suta1M0CgKVac82dO1eeffZZGTZsmLRu3Vratm0r1atXl+joaDl69KisX7/eLGkbHh4uQ4YMkYceesjzIwcAH2lds6x8tSSRYBYArBLMNmrUSH744QdJTEyU7777TubPny9//PGHnDhxQipWrCht2rSRDz/80GRlw8LCPD9qAPCDSWBr9yRLVrbN1NACACywaEKtWrXkiSeeMBsABKsGlctI6cgwSc/Iki0HU6Vx1ThfDwkAgpZLiya427x586Rnz56mZEH72E6ZMqXY55w6dUqee+45qV27tkRFRUmdOnXkk08+8cp4AUBpJrZFzZylvZkEBgBBHMxq14NWrVrJe++95/Rzbr31Vpk1a5Z8/PHHsmnTJvn6669NGQQAeFPrhHLmkrpZALBQmYG7aY2tbs6aNm2a/P7777J9+3YpX7682aeZWQDwttYJOZnZ1buSfT0UAAhqPg1mXfXTTz+ZTgpjxoyRL774QkqXLi3XXXedvPTSS2dd0EHLEnSzS0lJMZeZmZlm8wb7cbx1PLgX58/6PHEOm1YtYy437U+R5PQTEhNpqV+nlsPPobVx/qwv08vn0JXjWOq3r2ZkFyxYYFqCTZ48WQ4fPiz9+vWTI0eOmEUdCjNq1CgZMWJEgf3Tp0+XmJgY8Sbtwwvr4vxZn7vPYXxEmCRnhsjHk6ZLfeaAeQU/h9bG+bO+GV46h8ePH3f6sSG2Eiwurq25/vvf/8q2bdvk+++/lxo1aphMad26deXSSy919eVyBhISYgLUG2644ayP6d69uzn2/v37JT4+5yO+SZMmyc0332zqbwvLzhaWmU1ISDCBcFxcnNf+utCT361bN4mIiPDKMeE+nD/r89Q57PfVapmx4aA8c+V5cn8HSp48iZ9Da+P8WV+ml8+hxmva/jU5ObnYeM3lzKz2m73nnnvkrrvuklWrVjkCRT3YyJEj5ZdffhFPqVatmgmc7YGsatKkiVl9bPfu3dKwYcMCz9GOB7rlpyfC2z9Qvjgm3IfzZ33uPodtapczwezaPal8b3gJP4fWxvmzvggvnUNXjuFyN4OXX35Zxo0bZxZJyH2gDh06yMqVK8WT9Bh79+6VtLQ0x77NmzdLaGio1KxZ06PHBoDCVgJTdDQAAN9xOZjVdliXXXZZgf2aLT12zLVf6BqUrl692mxqx44d5rquNKZ0adzevXs7Hn/nnXdKhQoVpG/fvmYJXe1T++STT8p999131glgAOAp2ms2JERkz7ETcij1n3ImAIAfB7NVq1aVrVu3FtivE7Pq1avn0mstX77cLIWrmxo0aJC5/sILL5jb+/btcwS2qkyZMqZeQ4Nm7WqgpQ666MLbb7/t6tsAgHMWGx0hDSrldDVg8QQA8A2Xa2YffPBBGTBggFl1Sydt6cf+ixYtksGDB8vQoUNdeq3OnTubetezGT9+fIF9jRs3ZjYkAL/RKqGsbDmYJmt2H5OuTav4ejgAEHRcDmafeeYZyc7Oli5dupi2CVpyoBOsNJj997//7ZlRAoCfap1QVr5fsZu6WQCwSjCr2djnnnvO1KpquYHWvTZt2tSUAABAMAaz9jKD7GybhIaG+HpIABBUSrxoQmRkpAliASCYNaoaK1HhoZJy8rTsOJIu9c/U0AIA/DSYvfzyy0129mxmz559rmMCAMuICAuV5jXiZcXfR012lmAWAPw8mG3dunWBFSG0ndZff/0lffr0cefYAMASWtUs6whme51Pz2sA8Otg9o033ih0//Dhw/MsZgAAwaJ1rbIiC1k8AQAs0Wf2bO6++27TrgsAgnUlsPX7UuTU6SxfDwcAgorbglntNRsdHe2ulwMAy0goX0rKl46UzCybrN+b4uvhAEBQcbnMoFevXnlu66IHulKXrubl6qIJABAIdFJsq5rxMmfTIVM326ZWOV8PCQCChsvBbHx8fJ7boaGh0qhRI3nxxRele/fu7hwbAFhqJTANZqmbBQA/D2Y//fRTz4wEAAJh8YTdyb4eCgAEFbfVzAJAsLfnUjsOp8ux4xm+Hg4ABA2nMrPlypUrcqGE3JKSks51TABgOeVKR0qdCjGy88hxk53tdF4lXw8JAIKCU8Hsm2++6fmRAEAA1M2aYHbXMYJZAPCnYJaVvQDAuVKDH1fvZRIYAPjzBLDcTp48KRkZeWvD4uLiznVMAGDdlcB0EtiuY6ZtobPlWQAAL04AS09Pl0cffVQqV64spUuXNvW0uTcACFZNq8VJRFiIHEnPkN1HT/h6OAAQFFwOZp966imZPXu2vP/++xIVFSUfffSRjBgxQqpXry6ff/65Z0YJABYQHREmTarlfDpFqQEA+Gkw+/PPP8vYsWPlpptukvDwcOnYsaM8//zzMnLkSJkwYYJnRgkAFmvRpaUGAAA/DGa19Va9evUc9bH2VlyXXnqpzJs3z/0jBAALLp5AZhYA/DSY1UB2x44d5nrjxo3l22+/dWRsy5bN+SUOAMHcnkv9tTdZMrOyfT0cAAh4Lgezffv2lTVr1pjrzzzzjLz33nsSHR0tAwcOlCeffNITYwQAy6hXsbTERofLycxs2Xwg1dfDAYCA53RrrsGDB8sDDzxggla7rl27ysaNG2XFihXSoEEDadmypafGCQCWEBoaYupmF2w9bEoNmlWP9/WQACCgOZ2Z/fHHH6VZs2ZyySWXyCeffGJadKnatWtLr169CGQB4IxWCTkBLJPAAMCPgtktW7bInDlz5LzzzpMBAwZI1apV5b777pM//vjDsyMEAItpnZDTc5tJYADgZzWzl112mYwfP172798vb731lglwtYtBkyZN5D//+Y8cOHDAcyMFAItoVTMnM7vlYJqknTrt6+EAQEBzeQKY0pW/NCs7f/582bx5sykzGDVqlNSqVcv9IwQAi6kcFy3V46PFZhP5czfZWQDwu2DWTutmNaD9/fff5ejRo47+swAQ7FrXsi+ekOzroQBAQCtRMLtgwQKTma1WrZo89thjpo5Wg9oNGza4f4QAYEGsBAYAftaaa9++ffLZZ5+ZmlktLbj44ovl9ddfl9tvv13KlCnj2VECgMWwEhgA+Fkwm5CQIBUqVJB77rlH7r//fjPpCwBQuOY14iU0RGR/yknZn3xSqsZH+3pIABDcwawuW3vddddJeLjTTwGAoFU6KlzOqxIrG/enmuzslfFVfT0kAAjumlntWEAgCwCulxqsoaMBAPhnNwMAwNm1sgez1M0CgMcQzAKAhzOzf+5Olqxsm6+HAwABiWAWADykYeUyUioizKwCtv1Qmq+HAwABqcTB7NatW+W3336TEydOmNs2XeoGAOAQHhYqLWrkLG27ilIDAPCPYPbIkSPStWtXs1DC1VdfbfrPKm3X9cQTT3hijAAQACuBEcwCgF8EswMHDjRdDRITEyUmJsax/7bbbpNp06a5e3wAEBgrgdHRAAA8wuVeW9OnTzflBTVr1syzv2HDhvL333+7c2wAEDCZ2Y37UuVkZpZER4T5ekgAENyZ2fT09DwZWbukpCSJiopy17gAICBUj4+WimWi5HS2TdbtTfb1cAAg4LgczHbs2FE+//xzx+2QkBDJzs6WMWPGyOWXX+7u8QGApenvSHuLrlWJlBoAgM/LDDRo7dKliyxfvlwyMjLkqaeeknXr1pnM7MKFC90+QACwutYJ8TJzwwFZs5vMLAD4PDPbvHlz2bx5s1x66aVy/fXXm7IDXep21apVUr9+fbcPEACsjpXAAMCPMrMqPj5ennvuOfePBgACUMszHQ0Sk47LkbRTUqEM8wsAwGeZ2QYNGsjw4cNly5YtbhsEAASy+FIRUq9SacfStgAAHwaz/fv3l//973/SqFEjufDCC+Wtt96S/fv3u3FIABB4HJPAKDUAAN8vmrBs2TLZuHGjWQHsvffek4SEBOnevXueLgcAgILBLHWzAODjYNZOl7MdMWKEmQw2f/58OXTokPTt29e9owOAAFwJzGaz+Xo4ABDcE8Dsli5dKl999ZVMnDhRUlJS5JZbbnHfyAAggDSpFieRYaFy7Him/H3kuNSpmFNDCwDwcmZWM7HDhg0zmdkOHTrIhg0bZPTo0XLgwAH55ptvXHqtefPmSc+ePaV69eqmsfiUKVOcfq72tA0PD5fWrVu7+hYAwOsiw0OlafU4R3YWAOCjYLZx48Yybdo0MxFs9+7d8ttvv0nv3r2lTJkyLh9ce9S2atXK1N264tixY+aYungDAFgFK4EBgB+UGWzatEkaNmzoloNfddVVZnPVww8/LHfeeaeEhYW5lM0FAL+YBEZmFgB8F8y6K5AtqU8//VS2b98uX375pbz88svFPv7UqVNms9PaXpWZmWk2b7Afx1vHg3tx/qzPX85hs2o5dbLr9qZI+olTpvQA1jqHKBnOn/VlevkcunIcp4LZ8uXLm1rZihUrSrly5Ux969kkJSWJp+hCDc8884zpnqD1ss4YNWqU6bqQ3/Tp0yUmJka8acaMGV49HtyL82d9vj6H2sQgJixMjp/Olk8mTZNarldnBT1fn0OcG86f9c3w0jk8fvy40491KiJ84403JDY21nG9qGDWU7KyskxpgQamOvnMWUOGDJFBgwblycza++LGxeVMxvDGXxd68rt16yYRERFeOSbch/Nnff50Dn84vELmbz0isbWby9UX1fLpWKzEn84hXMf5s75ML59D+yfpbgtm+/Tp47h+7733ii+kpqbK8uXLZdWqVfLoo4+afdnZ2aZfo2ZpNdN6xRVXFHheVFSU2fLTE+HtHyhfHBPuw/mzPn84h21qlzfB7J97U+Vevp8seQ5Rcpw/64vw0jl05Rgu18zqpKt9+/ZJ5cqV8+w/cuSI2acZVE/QLOratWvz7Bs7dqzMnj1bvv/+e6lbt65HjgsA7tQ6Id5cshIYALiHy8Hs2Vau0UlWkZGRLr1WWlqabN261XF7x44dsnr1alOjW6tWLVMisGfPHrNMbmhoqDRv3jzP8zV4jo6OLrAfAPx9JbBth9Il+USmxJciSwUAXglm3377bXOp9bIfffRRnr6ymo3VBRC0B60rtGzg8ssvd9y217ZqWcP48eNNBjgxMdGl1wQAf1ahTJQklC8lu5JOyNrdyXJpw4q+HhIABEcwqxO/7JnZcePGmXIDO83I1qlTx+x3RefOnYtco1wD2qIMHz7cbABgteysBrPab5ZgFgC8FMxqCYDSTOqkSZNMiy4AQMkWT5j65z5WAgMAX9TMzpkzxx3HBQAJ9pXAVu86Zj6d8kW7QwAIFC4vP3PTTTfJ6NGjC+wfM2aM3HLLLe4aFwAErOY14iUsNEQOp52SvcknfT0cAAiuYFYnel199dUF9l911VXmPgBA0aIjwqRx1ZyFaGjRBQBeDma1nVZhLbi0ua0rqzUAQDBrlavUAADgxWC2RYsWMnHixAL7v/nmG2natOk5DAUAgrNuFgDgxQlgQ4cOlV69esm2bdscy8fOmjVLvv76a/nuu+/OYSgAEHzBrPaaPZ2VLeFhLucWAAAlCWZ79uwpU6ZMkZEjR5plZEuVKiUtW7aUmTNnSqdOnTwzSgAIMPUrlZEyUeGSduq0bDmYJk2qxfl6SAAQHMGsuuaaa8wGACgZ7WbQoka8LNp+xEwCI5gFgJIp0edax44dM0vaPvvss5KUlGT2rVy5Uvbs2VPCYQBA8GESGAD4IDP7559/SteuXSU+Pl527twpDzzwgJQvX96sCpaYmCiff/65G4YFAIGPSWAA4IPM7KBBg+Tee++VLVu2SHR0tGO/9p6lzywAuB7Mbj6QKsczTvt6OAAQHMHssmXL5KGHHiqwv0aNGrJ//353jQsAAl7V+GipGhct2bacrgYAAC8Es1FRUYUujrB582apVKlSCYYAAMGrVUK8uVyzm1IDAPBKMHvdddfJiy++KJmZmeZ2SEiIqZV9+umn5aabbirRIAAgWDEJDAC8HMy+9tprZknbypUry4kTJ0xv2QYNGkhsbKy88sor5zgcAAjOutk1uygzAACvdDPQLgYzZsyQBQsWmM4GGtief/75psMBAMA12ms2JERkz7ETcjD1pFSO/WdiLQDAQ4smqEsvvdRsAICSi42OkIaVy8jmA2kmO9utKcEsALg9mH377bflX//6l2nFpdeLUqZMGWnWrJlcdNFFLg0EAIJVq5plzwSzx6Rb0yq+Hg4ABF4w+8Ybb8hdd91lglm9XpRTp07JwYMHZeDAgfJ///d/7honAASs1rXKyncrdjMJDAA8Fczu2LGj0OtnozW1d955J8EsADiZmbW358rOtkloaIivhwQAgdvNwBlaS/v888974qUBIOA0qhorUeGhknrytOw4ku7r4QBA4Aezs2bNkmuvvVbq169vNr0+c+ZMx/2lSpWSAQMGuHOcABCwIsJCTVcDtTqRUgMA8GgwO3bsWLnyyitNX1kNWHWLi4uTq6++Wt577z1XXw4AkGvxBFYCAwAPt+YaOXKkmQT26KOPOvY99thj0qFDB3Nf//79XX1JAAh69sUTmAQGAB7OzB47dsxkZvPr3r27JCezgg0AnEswu2FfipzMzPL1cAAgcIPZ6667TiZPnlxg/48//mhqZwEArqtZrpSULx0pmVk2Wb8vxdfDAQDLcHrRBLumTZvKK6+8InPnzpX27dubfYsXL5aFCxfKE0884bmRAkAACwkJMdnZ2RsPmsUTzq9VztdDAoDAWjQht3Llysn69evNZle2bFn55JNPaMkFAOfQb9YezAIAPLRoAgDAcyuBKSaBAYAXFk04fPiw2QAA7tGqZk6v2Z1Hjsux4xm+Hg4ABF4wq50MtPVWxYoVpUqVKmbT69qmS+8DAJRc2ZhIqVMhxlwnOwsAbu4zm5SUZCZ87dmzR+666y5p0qSJ2a91s+PHjzergv3xxx+mnhYAUDI6CUwzs2t2JUvnRpV9PRwACJxg9sUXX5TIyEjZtm2bycjmv0/7zOpl/sliAADXVgKbsnovK4EBgLvLDKZMmSL/+c9/CgSyqmrVqjJmzJhC+88CAEq2EpjNZvP1cAAgcILZffv2SbNmzc56f/PmzWX//v3uGhcABKUm1eIkIixEktIzZPfRE74eDgAETjCrE7127txZZPuu8uXLu2tcABCUoiPCTECrVjEJDADcF8z26NFDnnvuOcnIKNgu5tSpUzJ06FC58sornX05AEAxpQYsngAAbp4A1rZtW2nYsKFpz9W4cWNTz7VhwwYZO3asCWi/+OILZ18OAFDESmAifxPMAoA7g9maNWvKokWLpF+/fjJkyBDHxARdT7xbt27y7rvvSkJCgrMvBwAoZiWwtXuSJTMrWyLCSry+DQAEPKeDWVW3bl359ddf5ejRo7Jlyxazr0GDBtTKAoAb1a1QWmKjwyX15GnZtD9VmtfIWRkMAHCOwaydLozQrl27kjwVAFCM0NAQUzc7f8th06KLYBYAzo7PrgDAb+tmmQQGAMUhmAUAP10JTGlmFgBwdgSzAOCHWiXklBZsPZQmqSczfT0cAPBbBLMA4Icqx0ZLjbKlRBvHaFcDAEDhCGYBwM8XT6DUAADOjmAWAPy81IBJYABwdgSzAODnHQ3IzALA2RHMAoCfalEzXkJDRA6knJL9ySd9PRwA8EsEswDgp2Iiw+W8KrHmOtlZAPDDYHbevHnSs2dPqV69uoSEhMiUKVOKfPykSZOkW7duUqlSJYmLi5P27dvLb7/95rXxAoC3talFqQEA+G0wm56eLq1atZL33nvP6eBXg9lffvlFVqxYIZdffrkJhletWuXxsQKAL7ASGAAULVx86KqrrjKbs9588808t0eOHCk//vij/Pzzz9KmTRsPjBAA/GMlsD93H5OsbJuEaREtAMA/gtlzlZ2dLampqVK+fPmzPubUqVNms0tJSTGXmZmZZvMG+3G8dTy4F+fP+qx8DuuWj5aYyDBJz8iSTXuPScMqZSQYWfkcgvMXCDK9fA5dOU6Izabry/ie1sxOnjxZbrjhBqefM2bMGHn11Vdl48aNUrly5UIfM3z4cBkxYkSB/V999ZXExMSc05gBwBve/itMtqWGyB31s+Tiyn7xKxsAPOr48eNy5513SnJyspknFZCZWQ1GNUjVMoOzBbJqyJAhMmjQoDyZ2YSEBOnevXuxXxx3/nUxY8YMU+8bERHhlWPCfTh/1mf1c7g2bLNsW7BTbOVry9VXN5VgZPVzGOw4f9aX6eVzaP8k3RmWDGa/+eYbeeCBB+S7776Trl27FvnYqKgos+WnJ8LbP1C+OCbch/NnfVY9h+fXLi+yYKes3ZNiyfG7k1XPIXJw/qwvwkvn0JVjWK7P7Ndffy19+/Y1l9dcc42vhwMAXpsEtnF/qpzIyPL1cADAr/g0mE1LS5PVq1ebTe3YscNcT0xMdJQI9O7dO09pgd5+7bXX5KKLLpL9+/ebTespACBQVY+PlkqxUaabwbq9/L4DAL8JZpcvX25aatnbamltq15/4YUXzO19+/Y5Alv1wQcfyOnTp6V///5SrVo1xzZgwACfvQcA8MYEWXu/WRZPAAA/qpnt3LmzFNVMYfz48Xluz5071wujAgD/XAls5oYDBLMAYPWaWQAI6pXAdhPMAkBuBLMAYAEtE+LN5a6kE3Ik7Z+FYAAg2BHMAoAFxEVHSP1Kpc11srMA8A+CWQCwWIuu1YkEswBgRzALABbRxh7M7qY9FwDYEcwCgMUys2t2HSuyEwwABBOCWQCwiMZV4yQyPFSST2TKziPHfT0cAPALBLMAYBEayDarHufIzgIACGYBwFJYCQwA8iKYBQCLrQSmCGYBIAfBLABYMDO7fm+KZJzO9vVwAMDnCGYBwEJqV4iRsjERkpGVLRv2pfh6OADgcwSzAGAhISEhjuwsK4EBAMEsAFgOK4EBwD8IZgHAsiuBEcwCAMEsAFhMy5rx5nL7oXSzgAIABDOCWQCwmAploqRW+Rhz/U+yswCCHMEsAFi4bpaVwAAEO4JZALCg1va6WYJZAEGOYBYALKh1Qk7d7OpdyWKz2Xw9HADwGYJZALCgZtXjJTw0RA6nnZI9x074ejgA4DMEswBgQdERYdK4Wqy5vmZXsq+HAwA+QzALABbFSmAAQDALANafBMZKYACCGMEsAFg8mF27J1lOZ2X7ejgA4BMEswBgUfUqlZEyUeFyIjNLNh9I8/VwAMAnCGYBwKLCQkMcS9tSNwsgWBHMAoCFtTgTzP60eo8s2nZEsrIDr+esvqclO5JkxeEQcxmI7xFAyYWfw3MBAD407a998u2yXeb6ou1Jsmj7YqkWHy3DejaVK5tXk0B5jyN+Xi/7kk9qLlo+37I84N4jgHNDZhYALBrkPfLlSjl6PDPP/v3JJ81+vT9Q3mNOIBuY7xHAuSMzCwAWox+za7aysA/b7fue+v5POZB6SiLDQk1tbURYiISFhppVw8x25nZEqF7m3A4PDc11Pf/tnOeGhYVIhH1/aIiEhob45D3qUfX+bk2rmrEACF4EswBgMUt3JBXIVuaXcvK0DPtxncfHonFk/iDYBMkmWLYHzmcC4fzX893OHXAnpZ8q8j1qQKv3z9pwQLo2qeKxoBqA/yOYBQCLOZhadCBrp50OKsdGS1Z2tpzOtsnpLJvJeGZmZ5tLvX36zH25b5vr+W5nZhU+6UrnYmVoj9ssEclb8eAV//pihQmoy5eOdGwVSkc5rlcso5c5tyuY65FSLibSr7K5+vXVP1D0vOr5ale3vF+ND/B3BLMAYDEa8DhjyFVNpH39Cm45ps1mM4GrCX5NkGsPgP8JhjOz/gmE89/OHxjn7M95Lcdjct3efihNvj4zua04Oq7DaRlmc0ZIiEjZUhFSocyZINcRBJ+5LBOVc/1M8Fs+JtJkkD0/wS0HE9wA1xDMAoDFaOZOAx6dCFVYvlRzelXjczJ87hISEiJhIdrbNkyivPA/hwa0czcfKvY9zn6is6SczJQjaRmSlJ4hR9JPmUvdNLjVcoWc/Tn7jh3PFJtNzMS5/JPnihKvwW+u7K5me/8Jfv/JBut1zfxGhoc6PcEt//uzT3B7/+7zCWgBJxDMAoDF6EfQmrnTgEeDutzBkP3Dab3fyh9VO/seS0WGma1KnHPZas0kaxBrgt60f4LcnMtTJii279Pt6PEME/wmn8g02/bD6U4dJzY6vGCmN1fwW7ZUpDw/5S8muAFuQDALABakGTvN3OX/iLpqAH1E7Yn3qOUClWKjzOZshvjY8ZwA1579NUFvriD4SNo/2WDdtOwh9eRps+08clxKwj7BbdG2w3Jpw0oleg0gWBDMAoBFaTCnmbtAnjxkf4+Lth6U6fOXSPeOF0n7BpW99h71OCazWiZKpErxj8/OtpkMbu4gN3em175/5+F02VtMRwrV55Ol0qByrJxXNVbOq1wm57JKrNQqHxNQ5xk4FwSzAGBhGtC4a5KXP7/Hi+qWlyMbbObSn4M4bRFWTjsmlI6UBpXLnPVxuvTwHR8uLvb1tInEpgOpZsstKjzUvL4GtjlbzvUaZUvRpgxBh2AWAAA/ncT39YMXy/bDabJpf5psOZAqmw+mypYDaXLqdLas25tittxiIsOkoQa3lctIo6qx5nqjKrFSJS7KTOIDAhHBLAAAfjrBrU7F0ma7onGVPHW8u5KOm2ytBribDuQEutsOpcnxjCxZs+uY2fJPSMudxdUAVwNd7cNLkAurI5gFAMBCE9w0ELYHuT2aVXXs176+fx9Jl80HNJObKlsOpppLnYSmk9FW/H3UbLlpd4WGubK49oxu2ZhID75zwL0IZgEACIBJfBFhWkcba7arW/wTCJ86nSU7DqfnBLga6J7J6P6ddNxMSluyI8lsuWm3h5zs7T9ZXM3oxkZHuDwuzSTr6684HCIVdiR5dQKftwT6Km5Zfn4OCWYBAAjgSXxR4WHSuGqc2XI7kZFlShM2n5lgZgLd/amy59gJOZR6ymwLth7O85zq8dE5dbiayT2TxdWJaDGR4U6scBYmn29ZHnArnAX6Km7TLHAOCWYBAAhCuthE8xrxZsst7dRpk7nV4DZ3oLs/5aRpJ6bb75sPOR6vJbcJ5WIcHRXs29aDqTLgm9UBvcJZoK/iNs0i749gFgAAOJSJCpc2tcqZLbfk45k5dbi5Al3ddNngxKTjZpu54WCxr28PjIZMWmv68lq1lZiO/dkiVnGz+nvMLub9+dMqdQSzAACgWPExEdK2Tnmz5aaLQOikM/uEMw101+1NlvSMrCJfT5cV7vfVKglkgfwebWdWqdNaYV/3uiaYBQAAJaaro7XXLVdA8+OqPTJg4upin1uvYmmpUMaanRN0eePth9OLfVxdfY+lrfcej6RnmImDxdFJb75GMAsAANyqcly0U4975cYWPs/qlZSzq7iNtOh7XOTk+9PuDb4W6usBAACAwFzh7GyVlLpf79fHWVWgv8d2Fnp/BLMAAMAjK5yp/MFQ7hXOfD1x6FwE+nsMs9D782kwO2/ePOnZs6dUr17dLKc3ZcqUYp8zd+5cOf/88yUqKkoaNGgg48eP98pYAQCA6yuc6Ypmueltf2npdK4C/T1eaZH359Oa2fT0dGnVqpXcd9990qtXr2Ifv2PHDrnmmmvk4YcflgkTJsisWbPkgQcekGrVqkmPHj28MmYAAODaCmeLth6U6fOXSPeOF/nd6lH+tIqbP7rSAufQp8HsVVddZTZnjRs3TurWrSuvvfaaud2kSRNZsGCBvPHGGwSzAAD4IQ16LqpbXo5ssJlLfwqCrLKKm6+F+fk5tFQ3g0WLFknXrl3z7NMg9vHHHz/rc06dOmU2u5SUFHOZmZlpNm+wH8dbx4N7cf6sj3NofZxDa+P8WV+ml8+hK8exVDC7f/9+qVKlSp59elsD1BMnTkipUqUKPGfUqFEyYsSIAvunT58uMTEx4k0zZszw6vHgXpw/6+McWh/n0No4f9Y3w0vn8Pjx44EZzJbEkCFDZNCgQY7bGvgmJCRI9+7dJS4uzmt/XejJ79atm0RERHjlmHAfzp/1cQ6tj3NobZw/68v08jm0f5IecMFs1apV5cCBA3n26W0NSgvLyirteqBbfnoivP0D5Ytjwn04f9bHObQ+zqG1cf6sL8JL59CVY1iqz2z79u1NB4Pc9K8E3Q8AAIDg49NgNi0tTVavXm02e+stvZ6YmOgoEejdu7fj8dqSa/v27fLUU0/Jxo0bZezYsfLtt9/KwIEDffYeAAAAEKTB7PLly6VNmzZmU1rbqtdfeOEFc3vfvn2OwFZpW67//e9/Jhur/Wm1RddHH31EWy4AAIAg5dOa2c6dO4vNZjvr/YWt7qXPWbVqlYdHBgAAACuwVM0sAAAAkBvBLAAAACyLYBYAAACWRTALAAAAyyKYBQAAgGVZagUwd7B3T3BlmTR3LAGnawzrMVn5xHo4f9bHObQ+zqG1cf6sL9PL59AepxXV9Spog9nU1FRzmZCQ4OuhAAAAoJi4LT4+vqiHSIjNmZA3gGRnZ8vevXslNjZWQkJCvHJM/etCg+ddu3ZJXFycV44J9+H8WR/n0Po4h9bG+bO+FC+fQw1PNZCtXr26hIYWXRUbdJlZ/YLUrFnTJ8fWk88PsXVx/qyPc2h9nENr4/xZX5wXz2FxGVk7JoABAADAsghmAQAAYFkEs14QFRUlw4YNM5ewHs6f9XEOrY9zaG2cP+uL8uNzGHQTwAAAABA4yMwCAADAsghmAQAAYFkEswAAALAsglkAAABYFsGsh7333ntSp04diY6OlosuukiWLl3q6yHBSaNGjZILL7zQrBZXuXJlueGGG2TTpk2+HhZK6NVXXzWr/j3++OO+HgpcsGfPHrn77rulQoUKUqpUKWnRooUsX77c18OCk7KysmTo0KFSt25dc/7q168vL730klndCf5p3rx50rNnT7Pylv7OnDJlSp779dy98MILUq1aNXNOu3btKlu2bBFfIpj1oIkTJ8qgQYNMK4uVK1dKq1atpEePHnLw4EFfDw1O+P3336V///6yePFimTFjhmRmZkr37t0lPT3d10ODi5YtWyb//e9/pWXLlr4eClxw9OhR6dChg0RERMivv/4q69evl9dee03KlSvn66HBSaNHj5b3339f3n33XdmwYYO5PWbMGHnnnXd8PTSchf4fp/GKJuMKo+fv7bfflnHjxsmSJUukdOnSJrY5efKk+AqtuTxIM7Ga2dMfYpWdnW3WNf73v/8tzzzzjK+HBxcdOnTIZGg1yL3ssst8PRw4KS0tTc4//3wZO3asvPzyy9K6dWt58803fT0sOEF/Ty5cuFDmz5/v66GghK699lqpUqWKfPzxx459N910k8noffnllz4dG4qnmdnJkyebTyaVhoyasX3iiSdk8ODBZl9ycrI5x+PHj5fbb79dfIHMrIdkZGTIihUrTPrdLjQ01NxetGiRT8eGktEfWFW+fHlfDwUu0Oz6Nddck+dnEdbw008/Sdu2beWWW24xf0i2adNGPvzwQ18PCy645JJLZNasWbJ582Zze82aNbJgwQK56qqrfD00lMCOHTtk//79eX6fxsfHm+SdL2ObcJ8dOcAdPnzY1ArpXyu56e2NGzf6bFwoGc2qa62lfuTZvHlzXw8HTvrmm29MiY+WGcB6tm/fbj6i1nKtZ5991pzHxx57TCIjI6VPnz6+Hh6czK6npKRI48aNJSwszPy/+Morr8hdd93l66GhBDSQVYXFNvb7fIFgFnAyu/fXX3+ZjAKsYdeuXTJgwABT76wTMGHNPyI1Mzty5EhzWzOz+nOotXoEs9bw7bffyoQJE+Srr76SZs2ayerVq01iQD+q5hzCXSgz8JCKFSuav0IPHDiQZ7/erlq1qs/GBdc9+uijMnXqVJkzZ47UrFnT18OBk7TMRydbar1seHi42bTeWScu6HXNEMG/6Wzppk2b5tnXpEkTSUxM9NmY4Jonn3zSZGe1llI7Udxzzz0ycOBA0y0G1lP1TPzib7ENwayH6MdgF1xwgakVyp1l0Nvt27f36djgHC1010BWi99nz55tWsvAOrp06SJr1641mSD7plk+/XhTr+sfm/BvWtaTvx2e1l7Wrl3bZ2OCa44fP27mi+SmP3v6/yGsp27duiZozR3baBmJdjXwZWxDmYEHaZ2Xfoyi/4G2a9fOzKDWlhd9+/b19dDgZGmBfjT2448/ml6z9nogLXbXmbjwb3rO8tc3awsZ7VdK3bM1aAZPJxBpmcGtt95q+nR/8MEHZoM1aL9SrZGtVauWKTNYtWqVvP7663Lffff5emgoogPM1q1b80z60gSATn7W86hlItoZpmHDhia41T7CWjZi73jgE9qaC57zzjvv2GrVqmWLjIy0tWvXzrZ48WJfDwlO0h+PwrZPP/3U10NDCXXq1Mk2YMAAXw8DLvj5559tzZs3t0VFRdkaN25s++CDD3w9JLggJSXF/Mzp/4PR0dG2evXq2Z577jnbqVOnfD00nMWcOXMK/b+vT58+5v7s7Gzb0KFDbVWqVDE/l126dLFt2rTJ5kv0mQUAAIBlUTMLAAAAyyKYBQAAgGURzAIAAMCyCGYBAABgWQSzAAAAsCyCWQAAAFgWwSwAAAAsi2AWAAAAlkUwCwBBok6dOmZZbQAIJASzAOAB9957r2Ot8s6dO5v1zL1l/PjxUrZs2QL7ly1bJv/617+8Ng4A8IZwrxwFAHDOMjIyJDIyssTPr1SpklvHAwD+gMwsAHg4Q/v777/LW2+9JSEhIWbbuXOnue+vv/6Sq666SsqUKSNVqlSRe+65Rw4fPux4rmZ0H330UZPVrVixovTo0cPsf/3116VFixZSunRpSUhIkH79+klaWpq5b+7cudK3b19JTk52HG/48OGFlhkkJibK9ddfb44fFxcnt956qxw4cMBxvz6vdevW8sUXX5jnxsfHy+233y6pqale+/oBQHEIZgHAgzSIbd++vTz44IOyb98+s2kAeuzYMbniiiukTZs2snz5cpk2bZoJJDWgzO2zzz4z2diFCxfKuHHjzL7Q0FB5++23Zd26deb+2bNny1NPPWXuu+SSS0zAqsGp/XiDBw8uMK7s7GwTyCYlJZlge8aMGbJ9+3a57bbb8jxu27ZtMmXKFJk6darZ9LGvvvqqR79mAOAKygwAwIM0m6nBaExMjFStWtWx/9133zWB7MiRIx37PvnkExPobt68Wc477zyzr2HDhjJmzJg8r5m7/lYzpi+//LI8/PDDMnbsWHMsPaZmZHMfL79Zs2bJ2rVrZceOHeaY6vPPP5dmzZqZ2toLL7zQEfRqDW5sbKy5rdljfe4rr7zitq8RAJwLMrMA4ANr1qyROXPmmI/47Vvjxo0d2VC7Cy64oMBzZ86cKV26dJEaNWqYIFMDzCNHjsjx48edPv6GDRtMEGsPZFXTpk3NxDG9L3ewbA9kVbVq1eTgwYMles8A4AlkZgHAB7TGtWfPnjJ69OgC92nAaKd1sblpve21114rjzzyiMmOli9fXhYsWCD333+/mSCmGWB3ioiIyHNbM76arQUAf0EwCwAeph/9Z2Vl5dl3/vnnyw8//GAyn+Hhzv8qXrFihQkmX3vtNVM7q7799ttij5dfkyZNZNeuXWazZ2fXr19vank1QwsAVkGZAQB4mAasS5YsMVlV7VagwWj//v3N5Ks77rjD1KhqacFvv/1mOhEUFYg2aNBAMjMz5Z133jETtrTTgH1iWO7jaeZXa1v1eIWVH3Tt2tV0RLjrrrtk5cqVsnTpUundu7d06tRJ2rZt65GvAwB4AsEsAHiYdhMICwszGU/t9aotsapXr246FGjg2r17dxNY6sQurVm1Z1wL06pVK9OaS8sTmjdvLhMmTJBRo0bleYx2NNAJYdqZQI+XfwKZvVzgxx9/lHLlyslll11mgtt69erJxIkTPfI1AABPCbHZbDaPvToAAADgQWRmAQAAYFkEswAAALAsglkAAABYFsEsAAAALItgFgAAAJZFMAsAAADLIpgFAACAZRHMAgAAwLIIZgEAAGBZBLMAAACwLIJZAAAAiFX9P9tPnYuD89N0AAAAAElFTkSuQmCC",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -467,8 +465,10 @@
     "    # Loop through the cases and extract iteration number and objective value\n",
     "    for i, case in enumerate(cases):\n",
     "        iterations.append(i)\n",
+    "        obj_keys = input_dict[\"analysis_options\"][\"objectives\"].keys()\n",
+    "        assert (len(obj_keys)) == 1\n",
     "        objective_values.append(\n",
-    "            case.get_objectives()[input_dict[\"analysis_options\"][\"objective\"][\"name\"]]\n",
+    "            case.get_objectives()[next(iter(obj_keys))]  # get the unique entry\n",
     "        )\n",
     "\n",
     "    # Plot the convergence\n",
@@ -490,7 +490,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/examples/03_offshore_floating_custom_system/inputs/ard_system.yaml b/examples/03_offshore_floating_custom_system/inputs/ard_system.yaml
index 9dfccf8d..462772b3 100644
--- a/examples/03_offshore_floating_custom_system/inputs/ard_system.yaml
+++ b/examples/03_offshore_floating_custom_system/inputs/ard_system.yaml
@@ -110,9 +110,8 @@ analysis_options:
       units: m
       lower: 852.0
       scaler: 0.0005  # 1/(7D)
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       units: km
       scaler: 0.05
   recorder:
diff --git a/examples/03_offshore_floating_custom_system/optimization_demo.ipynb b/examples/03_offshore_floating_custom_system/optimization_demo.ipynb
index c0617af4..ee2b15cf 100644
--- a/examples/03_offshore_floating_custom_system/optimization_demo.ipynb
+++ b/examples/03_offshore_floating_custom_system/optimization_demo.ipynb
@@ -45,13 +45,6 @@
    "id": "efa685c2",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mturbine_type has been changed without specifying a new reference_wind_height. reference_wind_height remains 90.00 m. Consider calling `FlorisModel.assign_hub_height_to_ref_height` to update the reference wind height to the turbine hub height.\u001b[0m\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -215,495 +208,454 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([7.]),\n",
       " 'spacing_secondary': array([7.])}\n",
-      "\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
+      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
+      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
+      "invalid value encountered in divide"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
       "Objectives\n",
       "{'collection.total_length_cables': array([21898.65877023])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|2\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.00109214]),\n",
-      " 'angle_skew': array([-0.00134399]),\n",
-      " 'spacing_primary': array([6.98051224]),\n",
-      " 'spacing_secondary': array([6.98052015])}\n",
+      "{'angle_orientation': array([-0.00239673]),\n",
+      " 'angle_skew': array([-0.00272629]),\n",
+      " 'spacing_primary': array([6.97727015]),\n",
+      " 'spacing_secondary': array([6.98376224])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([21837.91155865])}\n",
+      "{'collection.total_length_cables': array([21836.22502777])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|3\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([-0.00014881]),\n",
-      " 'angle_skew': array([-0.00631291]),\n",
-      " 'spacing_primary': array([6.73678083]),\n",
-      " 'spacing_secondary': array([6.83434807])}\n",
+      "{'angle_orientation': array([-0.00030682]),\n",
+      " 'angle_skew': array([-0.00442219]),\n",
+      " 'spacing_primary': array([6.86368585]),\n",
+      " 'spacing_secondary': array([6.90261968])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([21154.05797017])}\n",
+      "{'collection.total_length_cables': array([21524.28465243])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|4\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.02340924]),\n",
-      " 'angle_skew': array([0.11915457]),\n",
-      " 'spacing_primary': array([6.55391781]),\n",
-      " 'spacing_secondary': array([6.71842342])}\n",
+      "{'angle_orientation': array([-0.17659022]),\n",
+      " 'angle_skew': array([0.00565565]),\n",
+      " 'spacing_primary': array([6.55400585]),\n",
+      " 'spacing_secondary': array([6.66967644])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20636.16240077])}\n",
+      "{'collection.total_length_cables': array([20658.37740464])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|5\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.02342247]),\n",
-      " 'angle_skew': array([0.11960816]),\n",
-      " 'spacing_primary': array([6.55384636]),\n",
-      " 'spacing_secondary': array([6.710889])}\n",
+      "{'angle_orientation': array([-0.1817291]),\n",
+      " 'angle_skew': array([0.0036286]),\n",
+      " 'spacing_primary': array([6.55385026]),\n",
+      " 'spacing_secondary': array([6.6441251])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20630.13198583])}\n",
+      "{'collection.total_length_cables': array([20624.89369783])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|6\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.04096478]),\n",
-      " 'angle_skew': array([0.12898625]),\n",
-      " 'spacing_primary': array([6.55387122]),\n",
-      " 'spacing_secondary': array([6.67301083])}\n",
+      "{'angle_orientation': array([-0.21488191]),\n",
+      " 'angle_skew': array([-0.01122866]),\n",
+      " 'spacing_primary': array([6.55387314]),\n",
+      " 'spacing_secondary': array([6.55386945])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20600.69059806])}\n",
+      "{'collection.total_length_cables': array([20507.62305637])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|7\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964169]),\n",
-      " 'angle_skew': array([0.18509518]),\n",
-      " 'spacing_primary': array([6.55391654]),\n",
-      " 'spacing_secondary': array([6.55384863])}\n",
+      "{'angle_orientation': array([-0.21485191]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20508.02626244])}\n",
+      "{'collection.total_length_cables': array([20507.54362377])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|8\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964192]),\n",
-      " 'angle_skew': array([0.18509538]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21487334]),\n",
+      " 'angle_skew': array([-0.01122954]),\n",
+      " 'spacing_primary': array([6.55384619]),\n",
+      " 'spacing_secondary': array([6.55384603])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131483])}\n",
+      "{'collection.total_length_cables': array([20507.54364093])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|9\n",
       "--------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05965357]),\n",
-      " 'angle_skew': array([0.18507667]),\n",
-      " 'spacing_primary': array([6.55384616]),\n",
-      " 'spacing_secondary': array([6.55381198])}\n",
+      "{'angle_orientation': array([-0.2148616]),\n",
+      " 'angle_skew': array([-0.01123393]),\n",
+      " 'spacing_primary': array([6.55384617]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131694])}\n",
+      "{'collection.total_length_cables': array([20507.54363153])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|10\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964768]),\n",
-      " 'angle_skew': array([0.18508614]),\n",
-      " 'spacing_primary': array([6.55384616]),\n",
-      " 'spacing_secondary': array([6.55381197])}\n",
+      "{'angle_orientation': array([-0.21485629]),\n",
+      " 'angle_skew': array([-0.01123592]),\n",
+      " 'spacing_primary': array([6.55384617]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131602])}\n",
+      "{'collection.total_length_cables': array([20507.54362728])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|11\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964476]),\n",
-      " 'angle_skew': array([0.18509082]),\n",
+      "{'angle_orientation': array([-0.21485389]),\n",
+      " 'angle_skew': array([-0.01123682]),\n",
       " 'spacing_primary': array([6.55384616]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.8813163])}\n",
+      "{'collection.total_length_cables': array([20507.54362536])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|12\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964329]),\n",
-      " 'angle_skew': array([0.18509318]),\n",
+      "{'angle_orientation': array([-0.21485281]),\n",
+      " 'angle_skew': array([-0.01123723]),\n",
       " 'spacing_primary': array([6.55384616]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131558])}\n",
+      "{'collection.total_length_cables': array([20507.54362449])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|13\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964258]),\n",
-      " 'angle_skew': array([0.18509432]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485231]),\n",
+      " 'angle_skew': array([-0.01123741]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131524])}\n",
+      "{'collection.total_length_cables': array([20507.54362409])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|14\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964224]),\n",
-      " 'angle_skew': array([0.18509487]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485209]),\n",
+      " 'angle_skew': array([-0.01123749]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131502])}\n",
+      "{'collection.total_length_cables': array([20507.54362392])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|15\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964207]),\n",
-      " 'angle_skew': array([0.18509514]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485199]),\n",
+      " 'angle_skew': array([-0.01123753]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131489])}\n",
+      "{'collection.total_length_cables': array([20507.54362383])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|16\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.059642]),\n",
-      " 'angle_skew': array([0.18509526]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485194]),\n",
+      " 'angle_skew': array([-0.01123755]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131491])}\n",
+      "{'collection.total_length_cables': array([20507.5436238])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|17\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964196]),\n",
-      " 'angle_skew': array([0.18509533]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485192]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131481])}\n",
+      "{'collection.total_length_cables': array([20507.54362378])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|18\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964194]),\n",
-      " 'angle_skew': array([0.18509535]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485191]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131484])}\n",
+      "{'collection.total_length_cables': array([20507.54362377])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|19\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509537]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21487911]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384618]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131483])}\n",
+      "{'collection.total_length_cables': array([20507.54362138])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|20\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964233]),\n",
-      " 'angle_skew': array([0.18509432]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21486574]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384617]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131636])}\n",
+      "{'collection.total_length_cables': array([20507.54362256])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|21\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964213]),\n",
-      " 'angle_skew': array([0.18509485]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485895]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384617]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131552])}\n",
+      "{'collection.total_length_cables': array([20507.54362315])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|22\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964203]),\n",
-      " 'angle_skew': array([0.18509511]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485549]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131521])}\n",
+      "{'collection.total_length_cables': array([20507.54362346])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|23\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964198]),\n",
-      " 'angle_skew': array([0.18509524]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485373]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131502])}\n",
+      "{'collection.total_length_cables': array([20507.54362361])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|24\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964195]),\n",
-      " 'angle_skew': array([0.18509531]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485284]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131492])}\n",
+      "{'collection.total_length_cables': array([20507.54362369])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|25\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964194]),\n",
-      " 'angle_skew': array([0.18509534]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485239]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131488])}\n",
+      "{'collection.total_length_cables': array([20507.54362373])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|26\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964194]),\n",
-      " 'angle_skew': array([0.18509535]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485215]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131485])}\n",
+      "{'collection.total_length_cables': array([20507.54362375])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|27\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509536]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485204]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131484])}\n",
+      "{'collection.total_length_cables': array([20507.54362376])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|28\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509536]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485198]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131484])}\n",
+      "{'collection.total_length_cables': array([20507.54362377])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|29\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509537]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21485195]),\n",
+      " 'angle_skew': array([-0.01123756]),\n",
+      " 'spacing_primary': array([6.55384616]),\n",
+      " 'spacing_secondary': array([6.55384604])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131475])}\n",
+      "{'collection.total_length_cables': array([20507.54362377])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|30\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.05964227]),\n",
-      " 'angle_skew': array([0.18509466]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21537377]),\n",
+      " 'angle_skew': array([-0.01344261]),\n",
+      " 'spacing_primary': array([6.5538477]),\n",
+      " 'spacing_secondary': array([6.55384661])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131543])}\n",
+      "{'collection.total_length_cables': array([20507.54212323])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|31\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([0.0596421]),\n",
-      " 'angle_skew': array([0.18509502]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131502])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|32\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964201]),\n",
-      " 'angle_skew': array([0.1850952]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131486])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|33\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964197]),\n",
-      " 'angle_skew': array([0.18509528]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131486])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|34\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964195]),\n",
-      " 'angle_skew': array([0.18509532]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131487])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|35\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964194]),\n",
-      " 'angle_skew': array([0.18509535]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131485])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|36\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964194]),\n",
-      " 'angle_skew': array([0.18509536]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131484])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|37\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509536]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131484])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|38\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509536]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
+      "{'angle_orientation': array([-0.21528245]),\n",
+      " 'angle_skew': array([-0.01305378]),\n",
+      " 'spacing_primary': array([6.55384642]),\n",
+      " 'spacing_secondary': array([6.55384647])}\n",
       "\n",
       "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131483])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|39\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509537]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131483])}\n",
-      "\n",
-      "Driver debug print for iter coord: rank0:ScipyOptimize_SLSQP|40\n",
-      "---------------------------------------------------------------\n",
-      "Design Vars\n",
-      "{'angle_orientation': array([0.05964193]),\n",
-      " 'angle_skew': array([0.18509537]),\n",
-      " 'spacing_primary': array([6.55384615]),\n",
-      " 'spacing_secondary': array([6.55381196])}\n",
-      "\n",
-      "Objectives\n",
-      "{'collection.total_length_cables': array([20507.88131475])}\n",
+      "{'collection.total_length_cables': array([20507.54049904])}\n",
       "\n",
       "Iteration limit reached    (Exit mode 9)\n",
-      "            Current function value: 1.0253940657374143\n",
+      "            Current function value: 1.025377024951936\n",
       "            Iterations: 10\n",
-      "            Function evaluations: 40\n",
+      "            Function evaluations: 31\n",
       "            Gradient evaluations: 11\n",
       "Optimization FAILED.\n",
       "Iteration limit reached\n",
-      "-----------------------------------\n",
-      "-----------------\n",
-      "Total Derivatives\n",
-      "-----------------\n",
-      "\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| 'of' variable                      | 'wrt' variable    | calc val @ max viol | fd val @ max viol | (calc-fd) - (a + r*fd) | error desc        |\n",
-      "+====================================+===================+=====================+===================+========================+===================+\n",
-      "| AEP_farm                           | angle_orientation |        8.268781e+18 |     -4.521486e+10 |           8.268781e+18 |  8.268781e+18>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| AEP_farm                           | angle_skew        |       -8.233889e+18 |     -1.647045e+13 |           8.233873e+18 |  8.233873e+18>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| AEP_farm                           | spacing_primary   |        1.151021e+10 |     -7.717190e+09 |           1.922739e+10 |  1.922739e+10>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| AEP_farm                           | spacing_secondary |       -1.057630e+09 |     -3.253904e+10 |           3.148138e+10 |  3.148138e+10>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| collection.total_length_cables     | angle_orientation |       -1.580118e+00 |     -1.636772e+00 |           5.665216e-02 |  5.665216e-02>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| collection.total_length_cables     | angle_skew        |        8.732002e-01 |      1.098618e+00 |           2.254163e-01 |  2.254163e-01>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| collection.total_length_cables     | spacing_primary   |        1.168868e+03 |      9.087827e+02 |           2.600840e+02 |  2.600840e+02>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| collection.total_length_cables     | spacing_secondary |        1.948150e+03 |      7.785256e+02 |           1.169623e+03 |  1.169623e+03>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| spacing_constraint.turbine_spacing | angle_orientation |       -1.821301e-04 |      0.000000e+00 |           1.821301e-04 |  1.821301e-04>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| spacing_constraint.turbine_spacing | angle_skew        |       -1.874999e-04 |     -4.656613e-10 |           1.874994e-04 |  1.874994e-04>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| spacing_constraint.turbine_spacing | spacing_primary   |       -2.176563e-14 |      4.656613e-10 |           4.656826e-10 |  4.656826e-10>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
-      "| spacing_constraint.turbine_spacing | spacing_secondary |        8.412818e-15 |     -4.656613e-10 |           4.656692e-10 |  4.656692e-10>TOL |\n",
-      "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+      "-----------------------------------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">-----------------\n",
+       "Total Derivatives\n",
+       "-----------------\n",
+       "\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| 'of' variable                      | 'wrt' variable    | calc val @ max viol | fd val @ max viol | (calc-fd) - (a + r*fd) | error desc        |\n",
+       "+====================================+===================+=====================+===================+========================+===================+\n",
+       "| AEP_farm                           | angle_orientation |       -8.094546e+16 |     -1.305022e+11 |           8.094533e+16 |  8.094533e+16&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | angle_skew        |       -4.960043e+15 |     -1.431744e+10 |           4.960029e+15 |  4.960029e+15&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | spacing_primary   |        1.191941e+10 |      7.320247e+10 |           6.128299e+10 |  6.128299e+10&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | spacing_secondary |       -1.084265e+09 |      6.743824e+10 |           6.852244e+10 |  6.852244e+10&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| collection.total_length_cables     | angle_orientation |        1.250184e+00 |      1.546890e+00 |           2.967043e-01 |  2.967043e-01&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| collection.total_length_cables     | angle_skew        |        1.995466e+00 |      1.919636e+00 |           7.582854e-02 |  7.582854e-02&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | angle_orientation |       -2.456012e-04 |      9.313226e-10 |           2.456022e-04 |  2.456022e-04&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | angle_skew        |        3.571452e-02 |      3.568156e-02 |           3.292667e-05 |  3.292667e-05&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | spacing_primary   |       -2.955872e-15 |      2.328306e-10 |           2.328334e-10 |  2.328334e-10&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | spacing_secondary |        7.303186e-15 |     -9.313226e-10 |           9.313289e-10 |  9.313289e-10&gt;TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "-----------------\n",
+       "Total Derivatives\n",
+       "-----------------\n",
+       "\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| 'of' variable                      | 'wrt' variable    | calc val @ max viol | fd val @ max viol | (calc-fd) - (a + r*fd) | error desc        |\n",
+       "+====================================+===================+=====================+===================+========================+===================+\n",
+       "| AEP_farm                           | angle_orientation |       -8.094546e+16 |     -1.305022e+11 |           8.094533e+16 |  8.094533e+16>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | angle_skew        |       -4.960043e+15 |     -1.431744e+10 |           4.960029e+15 |  4.960029e+15>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | spacing_primary   |        1.191941e+10 |      7.320247e+10 |           6.128299e+10 |  6.128299e+10>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| AEP_farm                           | spacing_secondary |       -1.084265e+09 |      6.743824e+10 |           6.852244e+10 |  6.852244e+10>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| collection.total_length_cables     | angle_orientation |        1.250184e+00 |      1.546890e+00 |           2.967043e-01 |  2.967043e-01>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| collection.total_length_cables     | angle_skew        |        1.995466e+00 |      1.919636e+00 |           7.582854e-02 |  7.582854e-02>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | angle_orientation |       -2.456012e-04 |      9.313226e-10 |           2.456022e-04 |  2.456022e-04>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | angle_skew        |        3.571452e-02 |      3.568156e-02 |           3.292667e-05 |  3.292667e-05>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | spacing_primary   |       -2.955872e-15 |      2.328306e-10 |           2.328334e-10 |  2.328334e-10>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "| spacing_constraint.turbine_spacing | spacing_secondary |        7.303186e-15 |     -9.313226e-10 |           9.313289e-10 |  9.313289e-10>TOL |\n",
+       "+------------------------------------+-------------------+---------------------+-------------------+------------------------+-------------------+\n",
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
       "\n",
       "\n",
       "RESULTS (opt):\n",
       "\n",
-      "{'AEP_val': 405.4125610918656,\n",
-      " 'BOS_val': 992.4472464825666,\n",
+      "{'AEP_val': 405.40908466603213,\n",
+      " 'BOS_val': 992.4472468179093,\n",
       " 'CapEx_val': 118.75948972475001,\n",
-      " 'LCOE_val': 228.63254400878142,\n",
+      " 'LCOE_val': 228.63450461909613,\n",
       " 'OpEx_val': 9.350000000000001,\n",
-      " 'angle_orientation': 0.05964193123125717,\n",
-      " 'angle_skew': 0.18509536617932243,\n",
-      " 'area_tight': 11.614403395006365,\n",
-      " 'coll_length': 20.507881314748285,\n",
+      " 'angle_orientation': -0.21528244727673704,\n",
+      " 'angle_skew': -0.013053778441526186,\n",
+      " 'area_tight': 11.614465035800174,\n",
+      " 'coll_length': 20.507540499038722,\n",
       " 'mooring_spacing': -0.0010986122876681097,\n",
-      " 'spacing_primary': 6.5538461542542645,\n",
-      " 'spacing_secondary': 6.553811955062258,\n",
-      " 'turbine_spacing': 0.8520000000105875}\n",
+      " 'spacing_primary': 6.553846423635163,\n",
+      " 'spacing_secondary': 6.5538464685417015,\n",
+      " 'turbine_spacing': 0.8520000350725709}\n",
       "\n",
       "\n",
       "\n"
@@ -711,7 +663,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -776,8 +728,10 @@
     "    # Loop through the cases and extract iteration number and objective value\n",
     "    for i, case in enumerate(cases):\n",
     "        iterations.append(i)\n",
+    "        obj_keys = input_dict[\"analysis_options\"][\"objectives\"].keys()\n",
+    "        assert (len(obj_keys)) == 1\n",
     "        objective_values.append(\n",
-    "            case.get_objectives()[input_dict[\"analysis_options\"][\"objective\"][\"name\"]]\n",
+    "            case.get_objectives()[next(iter(obj_keys))]  # get the unique entry\n",
     "        )\n",
     "\n",
     "    # Plot the convergence\n",
@@ -799,7 +753,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/examples/05_onshore_batch/inputs/ard_system.yaml b/examples/05_onshore_batch/inputs/ard_system.yaml
index 69659d97..a5288b23 100644
--- a/examples/05_onshore_batch/inputs/ard_system.yaml
+++ b/examples/05_onshore_batch/inputs/ard_system.yaml
@@ -9,7 +9,7 @@ modeling_options:
     spacing_secondary: 7.0
     angle_orientation: 0.0
     angle_skew: 0.0
-  aero:      
+  aero:
     return_turbine_output: False
   floris:
     peak_shaving_fraction: 0.2
@@ -84,9 +84,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: "km"
       lower: 0.552
-  objective:
-    name: financese.lcoe
-    options:
+  objectives:
+    financese.lcoe:
       scaler: 1.0
   recorder:
     filepath: "cases.sql"
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 6707a90a..8ceeacfc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,7 +18,7 @@ include = ["ard", "ard.*"]
 
 [project]
 name = "ard-nrel"
-version = "0.1.0-beta0"
+version = "0.1.0-beta2"
 authors = [
   {name = "Cory Frontin", email = "cory.frontin@nrel.gov"},
   {name = "Rafael Mudafort", email = "rafael.mudafort@nrel.gov"},
diff --git a/test/system/ard/api/inputs_offshore_floating/ard_system.yaml b/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
index e52db2c7..1a62e96e 100644
--- a/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
+++ b/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
@@ -134,9 +134,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: "m"
       lower: 552
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       scaler: 1.0
   recorder:
     filepath: "cases.sql"
diff --git a/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml b/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
index 6f339006..7b8bcc12 100644
--- a/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
+++ b/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
@@ -127,9 +127,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: "m"
       lower: 552
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       scaler: 1.0
   recorder:
     filepath: "cases.sql"
diff --git a/test/system/ard/api/inputs_onshore/ard_system.yaml b/test/system/ard/api/inputs_onshore/ard_system.yaml
index d328d5d4..c7587536 100644
--- a/test/system/ard/api/inputs_onshore/ard_system.yaml
+++ b/test/system/ard/api/inputs_onshore/ard_system.yaml
@@ -101,9 +101,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: "m"
       lower: 552
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       scaler: 1.0
   recorder:
     filepath: "cases.sql"
\ No newline at end of file
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml b/test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml
index a59f941a..e1b5dc5e 100644
--- a/test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml
+++ b/test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml
@@ -98,9 +98,8 @@ analysis_options:
     spacing_constraint.turbine_spacing:
       units: "m"
       lower: 552
-  objective:
-    name: collection.total_length_cables
-    options:
+  objectives:
+    collection.total_length_cables:
       scaler: 1.0
   recorder:
     filepath: "cases.sql"
\ No newline at end of file
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
new file mode 100644
index 00000000..78ddf085
--- /dev/null
+++ b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
@@ -0,0 +1,99 @@
+modeling_options: &modeling_options
+  windIO_plant: !include windio.yaml
+  layout:
+      type: gridfarm
+      N_turbines: 25
+      N_substations: 1
+      spacing_primary: 7.0
+      spacing_secondary: 7.0
+      angle_orientation: 0.0
+      angle_skew: 0.0
+  aero:
+    return_turbine_output: True
+  floris:
+    peak_shaving_fraction: 0.2
+    peak_shaving_TI_threshold: 0.0
+
+system:
+  type: group
+  systems:
+    layout:
+      type: component
+      module: ard.layout.gridfarm
+      object: GridFarmLayout
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+    aepFLORIS:
+      type: component
+      module: ard.farm_aero.floris
+      object: FLORISAEP
+      promotes: ["AEP_farm"]
+      kwargs:
+        modeling_options: *modeling_options
+        data_path:
+        case_title: "default"
+    lug:
+      type: group
+      systems:
+        landuse:
+          type: component
+          module: ard.layout.gridfarm
+          object: GridFarmLanduse
+          promotes: ["*"]
+          kwargs:
+            modeling_options: *modeling_options
+      promotes: ["*"]
+    boundary:
+      type: component
+      module: ard.layout.boundary
+      object: FarmBoundaryDistancePolygon
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+  connections:
+    - ["x_turbines", "aepFLORIS.x_turbines"]
+    - ["x_turbines", "aepFLORIS.y_turbines"]
+
+analysis_options:
+  driver:
+    name: SimpleGADriver
+    options:
+      max_gen: 2
+      pop_size: 2
+      # optimizer: NSGA2
+      # opt_settings:
+      #   PopSize: 2
+      #   maxGen: 2
+      debug_print:
+        - desvars
+        - objs
+  design_variables:
+    spacing_primary:
+      lower:  3.0
+      upper: 20.0
+    spacing_secondary:
+      lower:  3.0
+      upper: 20.0
+    angle_orientation:
+      lower: -180.0
+      upper:  180.0
+    angle_skew:
+      lower: -45.0
+      upper:  45.0
+  constraints:
+    boundary_distances:
+      units: km
+      upper: 0.0
+      scaler: 2.0
+  objectives:
+    AEP_farm:
+      scaler: 1.0
+      units: GW*h
+    lug.landuse.area_tight:
+      scaler: 1.0
+      units: km**2
+      index: 0
+
+  recorder:
+    filepath: cases.sql
diff --git a/test/unit/ard/api/inputs_onshore/windio.yaml b/test/unit/ard/api/inputs_onshore/windio.yaml
new file mode 100644
index 00000000..91041a19
--- /dev/null
+++ b/test/unit/ard/api/inputs_onshore/windio.yaml
@@ -0,0 +1,34 @@
+name: Ard Example 01 onshore wind plant
+site:
+    name: Ard Example 01 offshore wind site
+    boundaries:
+        polygons:
+            - x: [ 1500.0,  3000.0,  3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0]
+              y: [ 3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0,  1500.0,  3000.0]
+    energy_resource:
+        name: Ard Example 01 offshore energy resource
+        wind_resource: !include ../../../../../examples/data/windIO-plant_wind-resource_wrg-example.yaml
+wind_farm:
+    name: Ard Example 01 offshore wind farm
+    layouts:
+        coordinates:
+            x: [
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0
+            ]
+            y: [
+                -2500.0, -2500.0, -2500.0, -2500.0, -2500.0,
+                -1250.0, -1250.0, -1250.0, -1250.0, -1250.0,
+                    0.0,     0.0,     0.0,     0.0,     0.0,
+                 1250.0,  1250.0,  1250.0,  1250.0,  1250.0,
+                 2500.0,  2500.0,  2500.0,  2500.0,  2500.0
+            ]
+    turbine: !include ../../../../../examples/data/windIO-plant_turbine_IEA-3.4MW-130m-RWT.yaml
+    electrical_substations:
+        - electrical_substation:
+            coordinates:
+                x: [100.0]
+                y: [100.0]
\ No newline at end of file
diff --git a/test/unit/ard/api/test_interface_unit.py b/test/unit/ard/api/test_interface_unit.py
index 79fccf3d..c75339de 100644
--- a/test/unit/ard/api/test_interface_unit.py
+++ b/test/unit/ard/api/test_interface_unit.py
@@ -21,7 +21,10 @@ def test_invalid_default_system(self):
 
         with pytest.raises(
             ValueError,
-            match=f"invalid default system 'test' specified. Must be one of \\['onshore', 'onshore_batch', 'onshore_no_cable_design', 'offshore_monopile', 'offshore_monopile_no_cable_design', 'offshore_floating', 'offshore_floating_no_cable_design'\\]",
+            match=f"invalid default system 'test' specified. Must be one of "
+            "\\['onshore', 'onshore_batch', 'onshore_no_cable_design', "
+            "'offshore_monopile', 'offshore_monopile_no_cable_design', "
+            "'offshore_floating', 'offshore_floating_no_cable_design'\\]",
         ):
             set_up_ard_model(input_dict)
 
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/unit/ard/api/test_multiobjective.py
new file mode 100644
index 00000000..b3980256
--- /dev/null
+++ b/test/unit/ard/api/test_multiobjective.py
@@ -0,0 +1,84 @@
+from pathlib import Path
+
+import openmdao.api as om
+
+from ard.utils.io import load_yaml
+from ard.api import set_up_ard_model
+
+import pytest
+
+
+class TestMultiobjectiveSetUp:
+    def setup_method(self):
+
+        # create the simplest system that will compile
+        input_dict = self.input_dict = load_yaml(
+            Path(__file__).parent / "inputs_onshore" / "ard_system_multiobjective.yaml"
+        )
+
+        # create an ard model
+        self.da_plough = set_up_ard_model(
+            input_dict=input_dict,
+        )
+
+    def test_response_variables(self, subtests):
+
+        # preemptively run the final setup
+        self.da_plough.final_setup()
+
+        # extract the response vars
+        response_vars = self.da_plough.list_driver_vars(out_stream=None)
+
+        # the expected responses
+        DVs_expected = {
+            "spacing_primary",
+            "spacing_secondary",
+            "angle_orientation",
+            "angle_skew",
+        }
+        constrs_expected = {
+            "boundary_distances",
+        }
+        objs_expected = {
+            "AEP_farm",
+            "lug.landuse.area_tight",
+        }
+
+        # use set equivalence to make sure the OM problem matches expectations
+        with subtests.test("design vars"):
+            assert (
+                set([v[0] for v in response_vars["design_vars"]]) == DVs_expected
+            ), "design vars must match"
+        with subtests.test("constraints"):
+            assert (
+                set([v[0] for v in response_vars["constraints"]]) == constrs_expected
+            ), "constraints must match"
+        with subtests.test("objectives"):
+            assert (
+                set([v[0] for v in response_vars["objectives"]]) == objs_expected
+            ), "objectives must match"
+
+    def test_raise_scipy_MOO_error(self):
+
+        self.input_dict["analysis_options"]["driver"]["name"] = "ScipyOptimizeDriver"
+        self.input_dict["analysis_options"]["driver"]["options"] = {
+            "optimizer": "COBYLA",
+            "opt_settings": {
+                "rhobeg": 2.0,
+                "maxiter": 50,
+            },
+        }
+
+        # re-create an ard model
+        self.da_plough = set_up_ard_model(
+            input_dict=self.input_dict,
+        )
+
+        # make sure the driver runs and gets the scipy error
+        with pytest.raises(
+            RuntimeError,
+            match="ScipyOptimizeDriver currently does not support multiple objectives.",
+        ):
+
+            # attempt to run the driver
+            self.da_plough.run_driver()

From 03153287aa39c7b1db285f5de3d38a8e069aaaba Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Mon, 3 Nov 2025 12:15:01 -0500
Subject: [PATCH 03/30] Add a simple viewshed component (#156)

* added viewshed and empty test component.

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* viewshed should be done

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* restore change i didn't like

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 ard/layout/viewshed.py                | 108 +++++++++++++++++
 test/unit/ard/layout/test_viewshed.py | 164 ++++++++++++++++++++++++++
 2 files changed, 272 insertions(+)
 create mode 100644 ard/layout/viewshed.py
 create mode 100644 test/unit/ard/layout/test_viewshed.py

diff --git a/ard/layout/viewshed.py b/ard/layout/viewshed.py
new file mode 100644
index 00000000..ff6611d6
--- /dev/null
+++ b/ard/layout/viewshed.py
@@ -0,0 +1,108 @@
+import numpy as np
+
+from shapely.geometry import Point
+from shapely.ops import unary_union
+
+import openmdao.api as om
+
+
+_R_earth = 6371008.8  # Earth radius, m
+
+
+def calculate_viewshed_section_angle(
+    D_rotor: float,  # rotor diameter, m
+    h_hub: float,  # hub height, m
+    R_earth: float = _R_earth,  # Earth radius, m
+    h_terrain: float = 0.0,  # mean height of prevailing terrain wrt turbine base, m
+) -> float:  # returns arc angle (rad) of viewshed
+    H = D_rotor / 2 + h_hub - h_terrain
+    return np.arccos(R_earth / (R_earth + H))
+
+
+def calculate_viewshed_arc_length(
+    D_rotor: float,  # rotor diameter, m
+    h_hub: float,  # hub height, m
+    R_earth: float = _R_earth,  # Earth radius, m
+    h_terrain: float = 0.0,  # mean height of prevailing terrain wrt turbine base, m
+) -> float:  # returns arc length of viewshed
+    angle_arc = calculate_viewshed_section_angle(
+        D_rotor,
+        h_hub,
+        R_earth=R_earth,
+        h_terrain=h_terrain,
+    )
+    return R_earth * angle_arc
+
+
+def calculate_viewshed_arc_length_smallangle(
+    D_rotor: float,  # rotor diameter, m
+    h_hub: float,  # hub height, m
+    R_earth: float = _R_earth,  # Earth radius, m
+    h_terrain: float = 0.0,  # mean height of prevailing terrain wrt turbine base, m
+) -> float:  # returns arc length of viewshed
+    angle_arc = calculate_viewshed_section_angle(
+        D_rotor,
+        h_hub,
+        R_earth=R_earth,
+        h_terrain=h_terrain,
+    )
+    return R_earth * np.sin(angle_arc)
+
+
+class ViewshedAreaComp(om.ExplicitComponent):
+    def initialize(self):
+        self.options.declare("modeling_options")
+
+    def setup(self):
+        self.modeling_options = self.options["modeling_options"]
+        self.windIO = self.modeling_options["windIO_plant"]
+
+        self.D_rotor = self.windIO["wind_farm"]["turbine"]["rotor_diameter"]
+        self.h_hub = self.windIO["wind_farm"]["turbine"]["hub_height"]
+        self.N_turbines = self.modeling_options["layout"]["N_turbines"]
+
+        self.add_input("x_turbines", np.zeros((self.N_turbines,)), units="m")
+        self.add_input("y_turbines", np.zeros((self.N_turbines,)), units="m")
+        # self.add_output('viewshed_arc_length', val=0.0, units='m', desc='Viewshed arc length')
+        self.add_output("area_viewshed", val=0.0, units="km**2", desc="Viewshed area")
+
+    def setup_partials(self):
+        # declare FD because no derivative is available
+        self.declare_partials("area_viewshed", "*", method="fd")
+
+    def compute(self, inputs, outputs):
+
+        # get the single-turbine viewshed arc length
+        D_rotor = self.D_rotor
+        h_hub = self.h_hub
+        h_terrain = 0.0
+
+        # project onto 2D surface plane
+        x_turbines = inputs["x_turbines"]
+        y_turbines = inputs["y_turbines"]
+        D_rotor_turbines = D_rotor * np.ones_like(x_turbines)
+        h_hub_turbines = h_hub * np.ones_like(x_turbines)
+        R_viewshed_turbines = calculate_viewshed_arc_length(
+            D_rotor_turbines,
+            h_hub_turbines,
+            h_terrain=h_terrain,
+        )
+
+        # create a list of shapely circles
+        viewshed_circles = [
+            Point(x, y).buffer(r)
+            for x, y, r in zip(
+                x_turbines.flatten(),
+                y_turbines.flatten(),
+                R_viewshed_turbines.flatten(),
+            )
+        ]
+
+        # compute the union of all circles
+        viewshed_union = unary_union(viewshed_circles)
+
+        # calculate the area of the union in square kilometers
+        viewshed_union_area_km2 = viewshed_union.area / 1e6
+
+        # pack and send output
+        outputs["area_viewshed"] = viewshed_union_area_km2
diff --git a/test/unit/ard/layout/test_viewshed.py b/test/unit/ard/layout/test_viewshed.py
new file mode 100644
index 00000000..450db3c0
--- /dev/null
+++ b/test/unit/ard/layout/test_viewshed.py
@@ -0,0 +1,164 @@
+import pytest
+import numpy as np
+from ard.layout import viewshed
+
+
+## HELPER FUNCTION TESTING
+
+
+# make sure that for various values the viewshed angles are in a sensible range
+@pytest.mark.parametrize(
+    "D_rotor, h_hub, h_terrain, expected_range",
+    [
+        (100.0, 80.0, 0.0, (0.0, 1.0 * (2.0 * np.pi / 360.0))),
+        (120.0, 100.0, 10.0, (0.0, 1.0 * (2.0 * np.pi / 360.0))),
+        (50.0, 60.0, 5.0, (0.0, 1.0 * (2.0 * np.pi / 360.0))),
+    ],
+)
+def test_calculate_viewshed_section_angle(D_rotor, h_hub, h_terrain, expected_range):
+    angle = viewshed.calculate_viewshed_section_angle(
+        D_rotor, h_hub, h_terrain=h_terrain
+    )
+    assert expected_range[0] <= angle <= expected_range[1]
+
+
+# make sure the small-angle approximation is coming in under the real number
+@pytest.mark.parametrize(
+    "D_rotor, h_hub, h_terrain",
+    [
+        (100.0, 80.0, 0.0),
+        (120.0, 100.0, 10.0),
+        (50.0, 60.0, 5.0),
+    ],
+)
+def test_calculate_viewshed_arc_length(D_rotor, h_hub, h_terrain):
+    arc_length = viewshed.calculate_viewshed_arc_length(
+        D_rotor, h_hub, h_terrain=h_terrain
+    )
+    assert arc_length > 0
+    # small angle approximation should be less than or equal to the full arc length
+    arc_length_small = viewshed.calculate_viewshed_arc_length_smallangle(
+        D_rotor, h_hub, h_terrain=h_terrain
+    )
+    assert arc_length_small <= arc_length
+
+
+## COMPONENT TESTING
+
+
+@pytest.fixture
+def modeling_options():
+    return {
+        "windIO_plant": {
+            "wind_farm": {
+                "turbine": {
+                    "rotor_diameter": 100,
+                    "hub_height": 80,
+                }
+            }
+        },
+        "layout": {"N_turbines": 3},
+    }
+
+
+# make sure the viewshed of three overlapping turbines is less the sum of three
+# turbines individual viewsheds but only slightly more than the viewshed of a
+# single turbine
+def test_viewshed_area_comp_overlap(modeling_options, subtests):
+
+    # create the component to test
+    comp = viewshed.ViewshedAreaComp(modeling_options=modeling_options)
+    comp.setup()
+    comp.setup_partials()
+
+    # place turbines close so circles overlap
+    x_turbines = np.array([0.0, 100.0, 200.0])
+    y_turbines = np.array([0.0, 0.0, 0.0])
+    inputs = {
+        "x_turbines": x_turbines,
+        "y_turbines": y_turbines,
+    }
+    outputs = {"area_viewshed": 0.0}
+
+    # make sure the area of the viewshed computed return a plausible value
+    comp.compute(inputs, outputs)
+
+    # area should be less than sum of individual circles
+    D_rotor = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["rotor_diameter"]
+    h_hub = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["hub_height"]
+    R_viewshed = viewshed.calculate_viewshed_arc_length(D_rotor, h_hub)
+    expected_area_nonoverlapping = 3 * np.pi * R_viewshed**2 / 1e6
+    expected_area_single_turbine = np.pi * R_viewshed**2 / 1e6
+    expected_area_pyrite = 5211.7651786  # computed 28 Oct 2025
+
+    with subtests.test("area less than non-overlapping sum"):
+        assert outputs["area_viewshed"] < expected_area_nonoverlapping
+    with subtests.test("area greater than single turbine viewshed"):
+        assert outputs["area_viewshed"] > expected_area_single_turbine
+    with subtests.test("area matches pyrite value"):
+        assert np.isclose(outputs["area_viewshed"], expected_area_pyrite)
+
+
+# make sure a single turbine viewshed is correct
+def test_viewshed_area_comp_single_turbine(modeling_options):
+
+    # create the component to test
+    modeling_options["layout"]["N_turbines"] = 1  # modify the modeling options
+    comp = viewshed.ViewshedAreaComp(modeling_options=modeling_options)
+    comp.setup()
+    comp.setup_partials()
+
+    # place a single turbine at the origin
+    x_turbines = np.array([0])
+    y_turbines = np.array([0])
+    inputs = {
+        "x_turbines": x_turbines,
+        "y_turbines": y_turbines,
+    }
+    outputs = {"area_viewshed": 0.0}
+
+    # compute the expected area for a single turbine (area of a circle)
+    D_rotor = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["rotor_diameter"]
+    h_hub = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["hub_height"]
+    R_viewshed = viewshed.calculate_viewshed_arc_length(D_rotor, h_hub)
+    n_segs = 16
+    expected_area = (
+        4 * n_segs * (0.5 * R_viewshed**2 * np.sin(2 * np.pi / (4 * n_segs))) / 1.0e6
+    )  # area of a equal-segmented approximation from shapely
+    # expected_area = np.pi * R_viewshed**2 / 1e6  # area of a circle
+
+    # compute with the component and verify
+    comp.compute(inputs, outputs)
+    assert np.isclose(outputs["area_viewshed"], expected_area, rtol=1e-3)
+
+
+# make sure a viewshed area of nonoverlapping turbines returns a 3x one turbine
+def test_viewshed_area_comp_three_nonoverlapping_turbines(modeling_options):
+
+    # create the component to test
+    comp = viewshed.ViewshedAreaComp(modeling_options=modeling_options)
+    comp.setup()
+    comp.setup_partials()
+
+    # place turbines far apart so circles don't overlap
+    x_turbines = np.array([50000.0, 0.0, -50000.0])
+    y_turbines = np.array([50000.0, -50000.0, 50000.0])
+    inputs = {
+        "x_turbines": x_turbines,
+        "y_turbines": y_turbines,
+    }
+    outputs = {"area_viewshed": 0.0}
+
+    # compute the expected area for three single turbines (via area of a circle)
+    D_rotor = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["rotor_diameter"]
+    h_hub = modeling_options["windIO_plant"]["wind_farm"]["turbine"]["hub_height"]
+    R_viewshed = viewshed.calculate_viewshed_arc_length(D_rotor, h_hub)
+    n_segs = 16
+    expected_area = 3 * (
+        4 * n_segs * (0.5 * R_viewshed**2 * np.sin(2 * np.pi / (4 * n_segs))) / 1.0e6
+    )  # area of an equal-segmented approximation from shapely
+    # expected_area = 3 * np.pi * R_viewshed**2 / 1e6
+
+    # compute with the component and verify
+    comp.compute(inputs, outputs)
+    assert np.isclose(outputs["area_viewshed"], expected_area, rtol=1e-3)

From da94d6ddab6d0b77cd212e3af30ffbba0e8a9944 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 2 Dec 2025 12:06:30 -0700
Subject: [PATCH 04/30] Remove zero velocity resource for FLORIS (#160)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* removed zero velocity rows from floris results

* adjust values with lt one percent error due to renormalization after wind resource pdf adjustment

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 ...indIO-plant_wind-resource_wrg-example.yaml | 50 +++++++++----------
 test/system/ard/api/test_interface.py         | 12 ++---
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/examples/data/windIO-plant_wind-resource_wrg-example.yaml b/examples/data/windIO-plant_wind-resource_wrg-example.yaml
index de6e625a..814dae8b 100644
--- a/examples/data/windIO-plant_wind-resource_wrg-example.yaml
+++ b/examples/data/windIO-plant_wind-resource_wrg-example.yaml
@@ -1,37 +1,37 @@
 reference_height: 90.0
 wind_direction: [0.0, 30.0, 60.0, 90.0, 120.0, 150.0, 180.0, 210.0, 240.0, 270.0, 300.0, 330.0]
-wind_speed: [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0]
+wind_speed: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0]
 probability:
     data:
-        -  [2.7905730483505822e-05, 0.0005308777338710849, 0.001678559568399788, 0.003288040399545356, 0.005191227262229483, 0.0071910131020355, 0.009065123677666334, 0.010590262536159968, 0.011576666314796107, 0.011903298542858102, 0.011543013499098413, 0.010568898265206135, 0.009138214931950337, 0.007457494479499178, 0.005738648225481273, 0.004158736062519513, 0.002834015182053526, 0.0018130797126548462, 0.0010870266976431822, 0.0006096354125378509, 0.0003192112635864782, 0.0001557457766581751, 7.066795201867939e-05, 2.975947246801929e-05, 1.1607700001429799e-05, 4.185071442071467e-06]
-        -  [0.00011013600191232096, 0.001228485441614485, 0.002878740386064356, 0.004610317157603805, 0.0062054716297177655, 0.007492093396745617, 0.008347281397613128, 0.008708650744814934, 0.008578908901570436, 0.008020004482239718, 0.007137629582080394, 0.00605973707160083, 0.004914096986622938, 0.0038096545192132366, 0.0028248728105408757, 0.0020040264189248934, 0.001360340842391198, 0.0008835446585162915, 0.0005490404920819867, 0.0003263665853822657, 0.00018554174931205785, 0.00010085689700996725, 5.240575816662973e-05, 2.6021625421123765e-05, 1.2343484905347602e-05, 5.591781953497985e-06]
-        -  [0.00015378212313800526, 0.0015484456269879464, 0.0033853263169155053, 0.0050942702532784795, 0.006415299288482878, 0.007185845514437615, 0.007351107063150027, 0.006961963179764584, 0.006151037222273892, 0.005093421689000818, 0.003964336402173925, 0.0029055675341125584, 0.0020077145292346486, 0.0013088908729542614, 0.000805425543507969, 0.0004679152195547015, 0.0002566632105509669, 0.000132923900898736, 6.498900306638768e-05, 2.9991854544587454e-05, 1.3061835196426703e-05, 5.367098434219161e-06, 2.0801578457882996e-06, 7.602454201563578e-07, 2.6193053258904465e-07, 8.504785891138251e-08]
-        -  [0.0001443500064719731, 0.001452241716780431, 0.0031669845531073523, 0.004743800666500173, 0.005933020683860206, 0.006584261676395334, 0.006656713637341662, 0.006214178454229883, 0.0053973018540752465, 0.00438141372372098, 0.0033336717116488265, 0.0023816413932808973, 0.0015994171854771826, 0.0010103611330477987, 0.0006006065786071858, 0.0003360328987502181, 0.00017695713238058901, 8.770404467871923e-05, 4.09047767504918e-05, 1.7949179125338e-05, 7.408440237835387e-06, 2.8754309683353964e-06, 1.0491699232988323e-06, 3.597669252922154e-07, 1.1590175117024618e-07, 3.5067883182449996e-08]
-        -  [0.00015281829015469306, 0.0015405039780889078, 0.0033794883711300025, 0.005117257002768983, 0.006504411538869736, 0.007377624174998393, 0.007668594530592864, 0.0074054421971233055, 0.006695819336148084, 0.005695392233228172, 0.0045709264205001515, 0.0034680133161853195, 0.0024905578082200204, 0.0016943457067207968, 0.001092484298402911, 0.0006678240546079614, 0.0003870816208735643, 0.00021273983035906616, 0.00011086075108421291, 5.476971764369453e-05, 2.5648876155024118e-05, 1.1383563540201956e-05, 4.787140438916885e-06, 1.9070406638810978e-06, 7.194843460280301e-07, 2.5700861240165746e-07]
-        -  [8.545141834464187e-05, 0.0011556924514356237, 0.003021064656643591, 0.0052093826962547685, 0.007437501162918033, 0.009448392455668597, 0.011018440104207288, 0.011983292831352079, 0.012261008532847343, 0.011862545857362333, 0.010885177513386543, 0.009489794810080545, 0.007867791276430528, 0.006205919323278252, 0.004657409489218838, 0.0033249724683594604, 0.002257260067351097, 0.0014565169637768334, 0.0008927738089742003, 0.0005194965638526213, 0.0002867756997179738, 0.00015007521497560777, 7.439792149176623e-05, 3.491154011978373e-05, 1.549530489741963e-05, 6.5000680592568205e-06]
-        -  [3.4534970303216116e-05, 0.0007043316874046679, 0.0023137648249113864, 0.004648423390520662, 0.007483677041708592, 0.010537795952450501, 0.013476294296139817, 0.015946736698633036, 0.017632831990583367, 0.018314004341308778, 0.0179130678943091, 0.016515678030889495, 0.01435253427467458, 0.011747195474547827, 0.00904433028101609, 0.006539957762025355, 0.004433501828972982, 0.002812127291632568, 0.0016654339223477253, 0.000918908345808675, 0.0004712893313110152, 0.0002241660902910936, 9.86504847463963e-05, 4.0072263239415405e-05, 1.4988694995210026e-05, 5.150071409353967e-06]
-        -  [0.00010597745385471734, 0.0012396448987188919, 0.002976866244823565, 0.004827907105545113, 0.00653384118352336, 0.007886035417125237, 0.008736472261244969, 0.009015125704583954, 0.008736353708131635, 0.007989485516148318, 0.006915431949268208, 0.005675634384941135, 0.004421506300856002, 0.003271481233793031, 0.0022996043262288055, 0.0015357278070565132, 0.0009742633706560882, 0.0005870003183832434, 0.00033578634835422386, 0.00018230024364643654, 9.389203314932511e-05, 4.58555067889334e-05, 2.1226069800254857e-05, 9.307865655885855e-06, 3.864696274130789e-06, 1.5186042118521152e-06]
-        -  [0.00025086141634871625, 0.0018401624471928804, 0.0033396613971678384, 0.004424138116932329, 0.005037130432991899, 0.0051885119610962736, 0.00494762573601618, 0.004422037766178741, 0.003732199521201938, 0.0029891250314640944, 0.0022794419941702198, 0.0016591371667545758, 0.0011547942526240573, 0.0007696864548284428, 0.0004918132249389136, 0.00030155081025270075, 0.00017755042233816914, 0.00010045174027777824, 5.463864017063892e-05, 2.858566038883178e-05, 1.43904841610314e-05, 6.973211863355572e-06, 3.2535268418333882e-06, 1.4620395805734827e-06, 6.329273574693588e-07, 2.6401887056824924e-07]
-        -  [0.00022187733933012402, 0.0014918516555573716, 0.002594262557638015, 0.0033734633344568244, 0.00382540566436906, 0.003970049478075742, 0.0038538748266555645, 0.0035409668699351734, 0.0031017116487976107, 0.002602589129288655, 0.0020988671690635842, 0.0016308119294914743, 0.0012231297587047144, 0.0008868009698573901, 0.0006222649674637278, 0.00042299883585060645, 0.0002787839434158181, 0.00017826176112267764, 0.0001106537043721774, 6.671344150635723e-05, 3.9083710902380845e-05, 2.225802944212477e-05, 1.2326541576898104e-05, 6.6404758728427e-06, 3.480866960127588e-06, 1.775912906021635e-06]
-        -  [0.0001292614007974042, 0.0010354655983545649, 0.0020239402458171888, 0.0029008910377104984, 0.0036184576614511745, 0.004144681009287854, 0.004464927682696144, 0.00458168843810482, 0.004512558574337849, 0.004286777171038865, 0.003940923995959381, 0.0035144346361710714, 0.003045530679124565, 0.002568007696391887, 0.0021091231062111146, 0.0016886232429964472, 0.001318780564373532, 0.001005200272146318, 0.0007481073813598215, 0.0005438335420760076, 0.00038627189817527226, 0.00026813872297047045, 0.0001819546326411422, 0.00012072251594455886, 7.832642573557663e-05, 4.9703526417928245e-05]
-        -  [2.503967103955221e-05, 0.00044437935129542884, 0.001353984166879072, 0.002594033929161307, 0.004038597622579454, 0.005550245866191746, 0.006979483821115485, 0.008177783943562266, 0.009016793876827514, 0.009408250176943992, 0.009319145070300192, 0.008777591860884029, 0.007867084223147221, 0.006710009629845851, 0.0054443628209316685, 0.004199498813862885, 0.0030767509855703775, 0.002138857288164006, 0.001409179597911644, 0.000878840438680717, 0.000518143543716873, 0.0002884058187976031, 0.00015134737965024435, 7.477483815654539e-05, 3.473211207788017e-05, 1.5145464264246264e-05]
+        -  [0.0005308777338710849, 0.001678559568399788, 0.003288040399545356, 0.005191227262229483, 0.0071910131020355, 0.009065123677666334, 0.010590262536159968, 0.011576666314796107, 0.011903298542858102, 0.011543013499098413, 0.010568898265206135, 0.009138214931950337, 0.007457494479499178, 0.005738648225481273, 0.004158736062519513, 0.002834015182053526, 0.0018130797126548462, 0.0010870266976431822, 0.0006096354125378509, 0.0003192112635864782, 0.0001557457766581751, 7.066795201867939e-05, 2.975947246801929e-05, 1.1607700001429799e-05, 4.185071442071467e-06]
+        -  [0.001228485441614485, 0.002878740386064356, 0.004610317157603805, 0.0062054716297177655, 0.007492093396745617, 0.008347281397613128, 0.008708650744814934, 0.008578908901570436, 0.008020004482239718, 0.007137629582080394, 0.00605973707160083, 0.004914096986622938, 0.0038096545192132366, 0.0028248728105408757, 0.0020040264189248934, 0.001360340842391198, 0.0008835446585162915, 0.0005490404920819867, 0.0003263665853822657, 0.00018554174931205785, 0.00010085689700996725, 5.240575816662973e-05, 2.6021625421123765e-05, 1.2343484905347602e-05, 5.591781953497985e-06]
+        -  [0.0015484456269879464, 0.0033853263169155053, 0.0050942702532784795, 0.006415299288482878, 0.007185845514437615, 0.007351107063150027, 0.006961963179764584, 0.006151037222273892, 0.005093421689000818, 0.003964336402173925, 0.0029055675341125584, 0.0020077145292346486, 0.0013088908729542614, 0.000805425543507969, 0.0004679152195547015, 0.0002566632105509669, 0.000132923900898736, 6.498900306638768e-05, 2.9991854544587454e-05, 1.3061835196426703e-05, 5.367098434219161e-06, 2.0801578457882996e-06, 7.602454201563578e-07, 2.6193053258904465e-07, 8.504785891138251e-08]
+        -  [0.001452241716780431, 0.0031669845531073523, 0.004743800666500173, 0.005933020683860206, 0.006584261676395334, 0.006656713637341662, 0.006214178454229883, 0.0053973018540752465, 0.00438141372372098, 0.0033336717116488265, 0.0023816413932808973, 0.0015994171854771826, 0.0010103611330477987, 0.0006006065786071858, 0.0003360328987502181, 0.00017695713238058901, 8.770404467871923e-05, 4.09047767504918e-05, 1.7949179125338e-05, 7.408440237835387e-06, 2.8754309683353964e-06, 1.0491699232988323e-06, 3.597669252922154e-07, 1.1590175117024618e-07, 3.5067883182449996e-08]
+        -  [0.0015405039780889078, 0.0033794883711300025, 0.005117257002768983, 0.006504411538869736, 0.007377624174998393, 0.007668594530592864, 0.0074054421971233055, 0.006695819336148084, 0.005695392233228172, 0.0045709264205001515, 0.0034680133161853195, 0.0024905578082200204, 0.0016943457067207968, 0.001092484298402911, 0.0006678240546079614, 0.0003870816208735643, 0.00021273983035906616, 0.00011086075108421291, 5.476971764369453e-05, 2.5648876155024118e-05, 1.1383563540201956e-05, 4.787140438916885e-06, 1.9070406638810978e-06, 7.194843460280301e-07, 2.5700861240165746e-07]
+        -  [0.0011556924514356237, 0.003021064656643591, 0.0052093826962547685, 0.007437501162918033, 0.009448392455668597, 0.011018440104207288, 0.011983292831352079, 0.012261008532847343, 0.011862545857362333, 0.010885177513386543, 0.009489794810080545, 0.007867791276430528, 0.006205919323278252, 0.004657409489218838, 0.0033249724683594604, 0.002257260067351097, 0.0014565169637768334, 0.0008927738089742003, 0.0005194965638526213, 0.0002867756997179738, 0.00015007521497560777, 7.439792149176623e-05, 3.491154011978373e-05, 1.549530489741963e-05, 6.5000680592568205e-06]
+        -  [0.0007043316874046679, 0.0023137648249113864, 0.004648423390520662, 0.007483677041708592, 0.010537795952450501, 0.013476294296139817, 0.015946736698633036, 0.017632831990583367, 0.018314004341308778, 0.0179130678943091, 0.016515678030889495, 0.01435253427467458, 0.011747195474547827, 0.00904433028101609, 0.006539957762025355, 0.004433501828972982, 0.002812127291632568, 0.0016654339223477253, 0.000918908345808675, 0.0004712893313110152, 0.0002241660902910936, 9.86504847463963e-05, 4.0072263239415405e-05, 1.4988694995210026e-05, 5.150071409353967e-06]
+        -  [0.0012396448987188919, 0.002976866244823565, 0.004827907105545113, 0.00653384118352336, 0.007886035417125237, 0.008736472261244969, 0.009015125704583954, 0.008736353708131635, 0.007989485516148318, 0.006915431949268208, 0.005675634384941135, 0.004421506300856002, 0.003271481233793031, 0.0022996043262288055, 0.0015357278070565132, 0.0009742633706560882, 0.0005870003183832434, 0.00033578634835422386, 0.00018230024364643654, 9.389203314932511e-05, 4.58555067889334e-05, 2.1226069800254857e-05, 9.307865655885855e-06, 3.864696274130789e-06, 1.5186042118521152e-06]
+        -  [0.0018401624471928804, 0.0033396613971678384, 0.004424138116932329, 0.005037130432991899, 0.0051885119610962736, 0.00494762573601618, 0.004422037766178741, 0.003732199521201938, 0.0029891250314640944, 0.0022794419941702198, 0.0016591371667545758, 0.0011547942526240573, 0.0007696864548284428, 0.0004918132249389136, 0.00030155081025270075, 0.00017755042233816914, 0.00010045174027777824, 5.463864017063892e-05, 2.858566038883178e-05, 1.43904841610314e-05, 6.973211863355572e-06, 3.2535268418333882e-06, 1.4620395805734827e-06, 6.329273574693588e-07, 2.6401887056824924e-07]
+        -  [0.0014918516555573716, 0.002594262557638015, 0.0033734633344568244, 0.00382540566436906, 0.003970049478075742, 0.0038538748266555645, 0.0035409668699351734, 0.0031017116487976107, 0.002602589129288655, 0.0020988671690635842, 0.0016308119294914743, 0.0012231297587047144, 0.0008868009698573901, 0.0006222649674637278, 0.00042299883585060645, 0.0002787839434158181, 0.00017826176112267764, 0.0001106537043721774, 6.671344150635723e-05, 3.9083710902380845e-05, 2.225802944212477e-05, 1.2326541576898104e-05, 6.6404758728427e-06, 3.480866960127588e-06, 1.775912906021635e-06]
+        -  [0.0010354655983545649, 0.0020239402458171888, 0.0029008910377104984, 0.0036184576614511745, 0.004144681009287854, 0.004464927682696144, 0.00458168843810482, 0.004512558574337849, 0.004286777171038865, 0.003940923995959381, 0.0035144346361710714, 0.003045530679124565, 0.002568007696391887, 0.0021091231062111146, 0.0016886232429964472, 0.001318780564373532, 0.001005200272146318, 0.0007481073813598215, 0.0005438335420760076, 0.00038627189817527226, 0.00026813872297047045, 0.0001819546326411422, 0.00012072251594455886, 7.832642573557663e-05, 4.9703526417928245e-05]
+        -  [0.00044437935129542884, 0.001353984166879072, 0.002594033929161307, 0.004038597622579454, 0.005550245866191746, 0.006979483821115485, 0.008177783943562266, 0.009016793876827514, 0.009408250176943992, 0.009319145070300192, 0.008777591860884029, 0.007867084223147221, 0.006710009629845851, 0.0054443628209316685, 0.004199498813862885, 0.0030767509855703775, 0.002138857288164006, 0.001409179597911644, 0.000878840438680717, 0.000518143543716873, 0.0002884058187976031, 0.00015134737965024435, 7.477483815654539e-05, 3.473211207788017e-05, 1.5145464264246264e-05]
     dims:
         -  wind_direction
         -  wind_speed
 turbulence_intensity:
     data:
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
-        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        -  [0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
     dims:
         -  wind_direction
         -  wind_speed
\ No newline at end of file
diff --git a/test/system/ard/api/test_interface.py b/test/system/ard/api/test_interface.py
index 6b06e31d..4938c646 100644
--- a/test/system/ard/api/test_interface.py
+++ b/test/system/ard/api/test_interface.py
@@ -19,7 +19,7 @@ def setup_method(self):
     def test_onshore_default_system_aep(self, subtests):
         with subtests.test("AEP_farm"):
             assert self.prob.get_val("AEP_farm", units="GW*h")[0] == pytest.approx(
-                384.60118796404765
+                385.1565821463874
             )
         with subtests.test("tcc.tcc"):
             assert self.prob.get_val("tcc.tcc", units="MUSD")[0] == pytest.approx(
@@ -40,7 +40,7 @@ def test_onshore_default_system_aep(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(39.400997200044735)
+            ] == pytest.approx(39.34418112669258)
 
 
 class TestSetUpArdModelOffshoreMonopile:
@@ -62,7 +62,7 @@ def test_offshore_monopile_default_system(self, subtests):
 
         with subtests.test("AEP_farm"):
             assert self.prob.get_val("AEP_farm", units="GW*h")[0] == pytest.approx(
-                2152.5162831487964
+                2155.624684938663
             )
         with subtests.test("tcc.tcc"):
             assert self.prob.get_val("tcc.tcc", units="MUSD")[0] == pytest.approx(
@@ -79,7 +79,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(99.10446644881932)
+            ] == pytest.approx(98.96155822224087)
 
 
 class TestSetUpArdModelOffshoreFloating:
@@ -101,7 +101,7 @@ def test_offshore_floating_default_system(self, subtests):
 
         with subtests.test("AEP_farm"):
             assert self.prob.get_val("AEP_farm", units="GW*h")[0] == pytest.approx(
-                2152.5162831487964
+                2155.624684938663
             )
         with subtests.test("tcc.tcc"):
             assert self.prob.get_val("tcc.tcc", units="MUSD")[0] == pytest.approx(
@@ -118,4 +118,4 @@ def test_offshore_floating_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(106.4797690940818)
+            ] == pytest.approx(106.32622571190157)

From 816d3c0dbcfb9666cbcb6fa3262752761704c52b Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Mon, 15 Dec 2025 14:09:40 -0700
Subject: [PATCH 05/30] Create a new automated stdout/stderr redirection system
 (#161)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* prototype stdout/stderr capturing implemented.

* missed a bunch, trying again.

* fix bounds manager

* adjust file paths

* clear ipynb

* remove viz script which isn't actually involved in that pr

* Apply typo suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fixed black formatting

* wip logging with iterations

* black reformatting

* remove messy iteration debug statements

* black reformat again

* update optimization demo

* update logging code for error handling and docs

* made stdio capture optional modeling option and updated

* bring floris input file generator in with logger

* added case name to address @jaredthomas68's comment on #161

* cleanup some iter_count discovery and defaulting code w/ multiple returns

* updated the logging docstrings

* ard system fixed

* fixing stuff and added some features related to the fixes

* try again to overcome windows error

* add teardown to fix windows file access issue

* use case_name distinction to make sure the reports end up in unique places

* wip try teardown to fix file access on windows

* fix discovered typo, test mistake

* added another necessary teardown

* forgot two more

* retry

* black reformat...

* adjust case names for better use

* black reformat...

* ... stupid omission

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 ard/api/interface.py                          |   40 +-
 ard/farm_aero/floris.py                       |   38 +-
 ard/utils/logging.py                          |  209 +++
 examples/01_onshore/inputs/ard_system.yaml    |    2 +
 examples/01_onshore/optimization_demo.ipynb   | 1644 ++++-------------
 .../inputs_offshore_floating/ard_system.yaml  |    1 +
 .../inputs_offshore_monopile/ard_system.yaml  |    1 +
 .../ard/api/inputs_onshore/ard_system.yaml    |    1 +
 test/system/ard/api/test_LCOE_LB_stack.py     |    6 +
 test/system/ard/api/test_LCOE_OFB_stack.py    |    6 +
 test/system/ard/api/test_LCOE_OFL_stack.py    |    8 +-
 .../ard/api/test_LCOE_OFL_stack_pyrite.npz    |  Bin 1300 -> 1300 bytes
 test/system/ard/api/test_interface.py         |   18 +
 .../ard_system_multiobjective.yaml            |    1 +
 test/unit/ard/api/test_multiobjective.py      |    6 +
 15 files changed, 725 insertions(+), 1256 deletions(-)
 create mode 100644 ard/utils/logging.py

diff --git a/ard/api/interface.py b/ard/api/interface.py
index 22b7d60c..88950d07 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -1,7 +1,10 @@
+from pathlib import Path
 import importlib
 import openmdao.api as om
 from openmdao.drivers.doe_driver import DOEGenerator
+from openmdao.utils.file_utils import clean_outputs
 from ard.utils.io import load_yaml, replace_key_value
+from ard.utils.logging import prepend_tabs_to_stdio
 from ard.cost.wisdem_wrap import (
     LandBOSSE_setup_latents,
     ORBIT_setup_latents,
@@ -113,7 +116,8 @@ def set_up_ard_model(input_dict: Union[str, dict], root_data_path: str = None):
 def set_up_system_recursive(
     input_dict: dict,
     system_name: str = "top_level",
-    work_dir: str = "ard_prob_out",
+    case_name: str | None = None,
+    work_dir: str = "case_files",
     parent_group=None,
     modeling_options: dict = None,
     analysis_options: dict = None,
@@ -130,19 +134,41 @@ def set_up_system_recursive(
     Returns:
         om.Problem: The OpenMDAO problem with the defined system hierarchy.
     """
+
+    # grab the case name if it's supplied in the system yaml
+    if case_name is None:
+        case_name = modeling_options.get(
+            "case_name",
+            input_dict.get("modeling_options", {}).get(
+                "case_name",
+                "ard_problem",
+            ),
+        )
+
     # Initialize the top-level problem if no parent group is provided
     if parent_group is None:
-        prob = om.Problem(work_dir=work_dir)
+        # clean out any pre-existing results for this problem
+        print("Running OpenMDAO util to clean the output directories...")
+        prepend_tabs_to_stdio(clean_outputs)(recurse=True, prompt=False)
+        print("... done.\n")
+
+        prob = om.Problem(
+            name=case_name,
+            work_dir=work_dir,
+        )
         parent_group = prob.model
-        # parent_group.name = "ard_model"
+
+        print(f"Created top-level OpenMDAO problem: {system_name}.")
     else:
         prob = None
 
     # Add subsystems directly from the input dictionary
     if hasattr(parent_group, "name") and (parent_group.name != ""):
-        print(f"Adding {system_name} to {parent_group.name}")
+        print(
+            f"{''.join(['\t' for _ in range(_depth)])}Adding {system_name} to {parent_group.name}."
+        )
     else:
-        print(f"Adding {system_name}")
+        print(f"{''.join(['\t' for _ in range(_depth)])}Adding {system_name}.")
     if "systems" in input_dict:  # Recursively add nested subsystems]
         if _depth > 0:
             group = parent_group.add_subsystem(
@@ -195,6 +221,9 @@ def set_up_system_recursive(
             src, tgt = connection  # Unpack the connection as [src, tgt]
             parent_group.connect(src, tgt)
 
+    if _depth == 0:
+        print(f"System {system_name} built.")
+
     # Set up the problem if this is the top-level call
     if prob is not None:
 
@@ -284,6 +313,7 @@ def set_up_system_recursive(
         )
 
         # setup the openmdao problem
+        print(f"System {system_name} set up.")
         prob.setup()
 
     return prob
diff --git a/ard/farm_aero/floris.py b/ard/farm_aero/floris.py
index 97d12742..0e436a1e 100644
--- a/ard/farm_aero/floris.py
+++ b/ard/farm_aero/floris.py
@@ -6,6 +6,7 @@
 import floris
 import floris.turbine_library.turbine_utilities
 
+import ard.utils.logging as ard_logging
 import ard.farm_aero.templates as templates
 
 
@@ -190,6 +191,7 @@ def initialize(self):
         """Initialization-time FLORIS management."""
         self.options.declare("case_title")
 
+    @ard_logging.component_log_capture
     def setup(self):
         """Setup-time FLORIS management."""
 
@@ -203,16 +205,17 @@ def setup(self):
             wind_shear=self.windIO["site"]["energy_resource"]["wind_resource"].get(
                 "shear"
             ),
-            reference_wind_height=(
-                self.wind_query.reference_height
-                if hasattr(self.wind_query, "reference_height")
-                else None
+            reference_wind_height=getattr(
+                self.wind_query,
+                "reference_height",
+                None,
             ),
         )
 
         self.case_title = self.options["case_title"]
-        self.dir_floris = Path("case_files", self.case_title, "floris_inputs")
-        self.dir_floris.mkdir(parents=True, exist_ok=True)
+        self.dir_floris = ard_logging.get_storage_directory(
+            self, "inputs", get_iter=True, clean=True
+        )
 
     def compute(self, inputs):
         """
@@ -340,13 +343,16 @@ def initialize(self):
         super().initialize()  # run super class script first!
         FLORISFarmComponent.initialize(self)  # FLORIS superclass
 
+    @ard_logging.component_log_capture
     def setup(self):
         super().setup()  # run super class script first!
         FLORISFarmComponent.setup(self)  # setup a FLORIS run
 
+    @ard_logging.component_log_capture
     def setup_partials(self):
         FLORISFarmComponent.setup_partials(self)
 
+    @ard_logging.component_log_capture
     def compute(self, inputs, outputs):
 
         # generate the list of conditions for evaluation
@@ -362,10 +368,10 @@ def compute(self, inputs, outputs):
             layout_y=inputs["y_turbines"],
             wind_data=self.time_series,
             yaw_angles=np.array([inputs["yaw_turbines"]]),
-            reference_wind_height=(
-                self.wind_query.reference_height
-                if hasattr(self.wind_query, "reference_height")
-                else None
+            reference_wind_height=getattr(
+                self.wind_query,
+                "reference_height",
+                None,
             ),
         )
         if "peak_shaving_fraction" in self.modeling_options.get("floris", {}):
@@ -442,13 +448,16 @@ def initialize(self):
         super().initialize()  # run super class script first!
         FLORISFarmComponent.initialize(self)  # add on FLORIS superclass
 
+    @ard_logging.component_log_capture
     def setup(self):
         super().setup()  # run super class script first!
         FLORISFarmComponent.setup(self)  # setup a FLORIS run
 
+    @ard_logging.component_log_capture
     def setup_partials(self):
         super().setup_partials()
 
+    @ard_logging.component_log_capture
     def compute(self, inputs, outputs):
 
         # set up and run the floris model
@@ -457,10 +466,10 @@ def compute(self, inputs, outputs):
             layout_y=inputs["y_turbines"],
             wind_data=self.wind_query,
             yaw_angles=np.array([inputs["yaw_turbines"]]),
-            reference_wind_height=(
-                self.wind_query.reference_height
-                if hasattr(self.wind_query, "reference_height")
-                else None
+            reference_wind_height=getattr(
+                self.wind_query,
+                "reference_height",
+                None,
             ),
         )
         if "peak_shaving_fraction" in self.modeling_options.get("floris", {}):
@@ -477,5 +486,6 @@ def compute(self, inputs, outputs):
         outputs["power_turbines"] = FLORISFarmComponent.get_power_turbines(self)
         outputs["thrust_turbines"] = FLORISFarmComponent.get_thrust_turbines(self)
 
+    @ard_logging.component_log_capture
     def setup_partials(self):
         FLORISFarmComponent.setup_partials(self)
diff --git a/ard/utils/logging.py b/ard/utils/logging.py
new file mode 100644
index 00000000..9d6a0da0
--- /dev/null
+++ b/ard/utils/logging.py
@@ -0,0 +1,209 @@
+from contextlib import redirect_stdout, redirect_stderr
+from functools import wraps
+from io import StringIO
+from pathlib import Path
+import shutil
+import sys
+
+import openmdao.core.component
+
+
+def extract_iter(component):
+    """
+    Extract the iter_count iff it exists, otherwise return None
+
+    Extract the iteration count from a component's associated model.
+    This function attempts to retrieve the iteration count from a component by
+    traversing through its problem metadata and model reference. It safely
+    handles cases where any of the required attributes or keys don't exist.
+
+    Parameters
+    ----------
+        component: An object that may contain a _problem_meta attribute with
+                  model reference information.
+    Returns
+    -------
+        int or None: The iteration count from the model if it exists and is
+                    accessible, otherwise None.
+            The function returns None in the following cases:
+            - component doesn't have a _problem_meta attribute
+            - problem_meta doesn't contain a "model_ref" key
+            - the model doesn't have an iter_count attribute
+    """
+
+    # extract the iter count if it exists, returning and handling none otherwise
+    problem_meta = getattr(component, "_problem_meta", None)
+    model = problem_meta.get("model_ref", lambda _: None)()
+    iter_count = getattr(model, "iter_count", None)
+
+    return iter_count
+
+
+def get_storage_directory(
+    component,
+    storage_type: str = "logs",
+    get_iter: bool = False,
+    clean: bool = False,
+):
+    """
+    Get a storage directory for the component constructed here.
+
+    Take a component and create a storage directory (for, e.g. logs or init
+    files), mirroring the OpenMDAO model structure as subdirectories, returning
+    a pathlib.Path to the storage directory.
+
+    Parameters
+    ----------
+    component : openmdao.core.Component
+        an OpenMDAO component for which we want to create a storage directory
+    storage_type : str, optional
+        the type of storage sub-directory to make, by default "logs"
+    get_iter : bool, optional
+        should the storage directory tree be given an iteration subdirectory, by
+        default False
+    clean : bool, optional
+        should the directory tree, if it already exists, be cleaned out, by
+        default False
+
+    Returns
+    -------
+    pathlib.Path
+        the path to the storage subdirectory created
+    """
+    # the storage type we're doing (logs, discipline scripts, etc.)
+    storage_dir = [
+        storage_type,
+    ]
+    # if there's an iteration number to grab, grab it and add it to the dir
+    iter = extract_iter(component) if get_iter else None
+    if iter:
+        storage_dir += [f"iter_{iter:04d}"]
+    # mirror the comp path for a log directory
+    subdir_logger = component.pathname.split(".")
+    # find the reports directory
+    dir_reports = Path(component._problem_meta["reports_dir"])
+    # put the storage directory next to it
+    path_storage = Path(dir_reports.parent, *storage_dir, *subdir_logger)
+
+    # make a clean log location for this component if permitted
+    try:
+        path_storage.mkdir(parents=True, exist_ok=False)
+    except FileExistsError:  # handle a FileExists, but raise anything else
+        if clean:
+            shutil.rmtree(path_storage, ignore_errors=True)
+            path_storage.mkdir(parents=True, exist_ok=True)
+        else:
+            raise
+
+    return path_storage
+
+
+def name_create_log(component, iter: int = None):
+    """
+    For a given component, clean and create component- and rank-unique logfiles.
+
+    Take a component and create logs, parallel to the reports file, mirroring
+    the OpenMDAO model structure with stdout and stderr files for each rank,
+    and finally return the file paths for the component to redirect stdout and
+    stderr to.
+
+    Parameters
+    ----------
+    component : openmdao.core.component.Component
+        An OpenMDAO component that we want to capture stdout/stderr for
+
+    Returns
+    -------
+    pathlib.Path
+        a path to in the log system to dump stdout to
+    pathlib.Path
+        a path to in the log system to dump err to
+    """
+
+    # make sure we are dealing with an OM component
+    if not isinstance(component, openmdao.core.component.Component):
+        raise TypeError(
+            f"Expected openmdao.core.component.Component, got {type(component)}"
+        )
+
+    path_logfile_template = (
+        get_storage_directory(component, "logs", True, clean=True)
+        / f"%s_rank{component._comm.rank:03d}.txt"
+    )
+    path_logfile_stdout = Path(path_logfile_template.as_posix() % "stdout")
+    path_logfile_stderr = Path(path_logfile_template.as_posix() % "stderr")
+
+    # return stdout and stderr files
+    return path_logfile_stdout.absolute(), path_logfile_stderr.absolute()
+
+
+def component_log_capture(compute_func, iter: int = None):
+    """
+    Decorator that redirects stdout and stderr to component-wise and rank-wise logfiles.
+
+    This decorator will redirect stdout and stderr to component-wise and
+    rank-wise logfiles, which are determined by the `name_create_log` function.
+    The decorator uses context managers to redirect output streams to these
+    files, ensuring that all print statements and errors within the function are
+    logged appropriately.
+
+    func : Callable
+        The function to be decorated. It should be a method of a class, as
+        `self` is expected as the first argument.
+
+    Callable
+        The wrapped function with stdout and stderr redirected to log files
+        during its execution.
+    """
+
+    @wraps(compute_func)
+    def wrapper(self, *args, **kwargs):
+
+        # extract from modeling options the stdio_capture option iff it exists
+        stdio_capture = getattr(self, "modeling_options", {}).get("stdio_capture")
+        # bail out, returning the function w/ no changes if it doesn't
+        if not stdio_capture:
+            return compute_func(self, *args, **kwargs)
+
+        # if we get here, we want to capture stdio
+
+        # get log file paths
+        path_stdout_log, path_stderr_log = name_create_log(self)
+
+        try:
+            # use context manager to redirect stdout & stderr
+            with (
+                open(path_stdout_log, "a") as stdout_file,
+                open(path_stderr_log, "a") as stderr_file,
+                redirect_stdout(stdout_file),
+                redirect_stderr(stderr_file),
+            ):
+                return compute_func(self, *args, **kwargs)
+        except Exception:
+            raise  # make sure the exception is raised
+
+    return wrapper
+
+
+def prepend_tabs_to_stdio(func, tabs=1):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        old_stdout = sys.stdout
+        sys.stdout = StringIO()
+
+        # run the function
+        returns = func(*args, **kwargs)
+
+        # get capture output and restore stdout
+        output = sys.stdout.getvalue()
+        sys.stdout = old_stdout
+
+        tabset = "".join(["\t" for t in range(tabs)])
+        if output:
+            for line in output.splitlines():
+                print(f"{tabset}{line}")
+
+        # pass through the returns of the function
+        return returns
+
+    return wrapper
diff --git a/examples/01_onshore/inputs/ard_system.yaml b/examples/01_onshore/inputs/ard_system.yaml
index 9adf5102..58849469 100644
--- a/examples/01_onshore/inputs/ard_system.yaml
+++ b/examples/01_onshore/inputs/ard_system.yaml
@@ -1,4 +1,5 @@
 modeling_options:
+  case_name: COBYLA_optimization
   windIO_plant: !include windio.yaml
   layout:
     type: gridfarm
@@ -43,6 +44,7 @@ modeling_options:
     interconnect_voltage_kV: 130.0
     tcc_per_kW: 1300.00  # (USD/kW)
     opex_per_kW: 44.00  # (USD/kWh)
+  stdio_capture: True
 
 system: onshore
 
diff --git a/examples/01_onshore/optimization_demo.ipynb b/examples/01_onshore/optimization_demo.ipynb
index 04b723e6..03ef2b7f 100644
--- a/examples/01_onshore/optimization_demo.ipynb
+++ b/examples/01_onshore/optimization_demo.ipynb
@@ -17,16 +17,7 @@
    "execution_count": 1,
    "id": "d75b4457",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: <frozen importlib._bootstrap>:488\n",
-      "numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path  # optional, for nice path specifications\n",
     "\n",
@@ -60,34 +51,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "29850609",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mturbine_type has been changed without specifying a new reference_wind_height. reference_wind_height remains 90.00 m. Consider calling `FlorisModel.assign_hub_height_to_ref_height` to update the reference wind height to the turbine hub height.\u001b[0m\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Adding top_level\n",
-      "Adding layout2aep\n",
-      "Adding layout to layout2aep\n",
-      "Adding aepFLORIS to layout2aep\n",
+      "Running OpenMDAO util to clean the output directories...\n",
+      "\tFound 1 OpenMDAO output directories:\n",
+      "\tRemoved case_files/COBYLA_optimization_out\n",
+      "\tRemoved 1 OpenMDAO output directories.\n",
+      "... done.\n",
+      "\n",
+      "Created top-level OpenMDAO problem: top_level.\n",
+      "Adding top_level.\n",
+      "\tAdding layout2aep.\n",
+      "\t\tAdding layout to layout2aep.\n",
+      "\t\tAdding aepFLORIS to layout2aep.\n",
       "\tActivating approximate totals on layout2aep\n",
-      "Adding boundary\n",
-      "Adding landuse\n",
-      "Adding collection\n",
-      "Adding spacing_constraint\n",
-      "Adding tcc\n",
-      "Adding landbosse\n",
-      "Adding opex\n",
-      "Adding financese\n"
+      "\tAdding boundary.\n",
+      "\tAdding landuse.\n",
+      "\tAdding collection.\n",
+      "\tAdding spacing_constraint.\n",
+      "\tAdding tcc.\n",
+      "\tAdding landbosse.\n",
+      "\tAdding opex.\n",
+      "\tAdding financese.\n",
+      "System top_level built.\n",
+      "System top_level set up.\n"
      ]
     }
    ],
@@ -138,17 +131,6 @@
    "id": "b74f9d45",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/openmdao/recorders/sqlite_recorder.py:231: UserWarning:The existing case recorder file, ard_prob_out/problem_out/cases.sql, is being overwritten.\n",
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -157,10 +139,10 @@
       "\n",
       "RESULTS:\n",
       "\n",
-      "{'AEP_val': 405.9510682648514,\n",
+      "{'AEP_val': 406.5372933434125,\n",
       " 'BOS_val': 41.68227106807093,\n",
       " 'CapEx_val': 110.5,\n",
-      " 'LCOE_val': 37.328810082644566,\n",
+      " 'LCOE_val': 37.274982094458494,\n",
       " 'OpEx_val': 3.7400000000000007,\n",
       " 'area_tight': 13.2496,\n",
       " 'coll_length': 21.89865877023397,\n",
@@ -228,25 +210,9 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([7.]),\n",
       " 'spacing_secondary': array([7.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03732881])}\n",
+      "{'financese.lcoe': array([0.03727498])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|1\n",
       "---------------------------------------------------------------\n",
@@ -255,25 +221,9 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([7.]),\n",
       " 'spacing_secondary': array([7.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03732881])}\n",
+      "{'financese.lcoe': array([0.03727498])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|2\n",
       "---------------------------------------------------------------\n",
@@ -282,25 +232,9 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([9.]),\n",
       " 'spacing_secondary': array([7.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03630168])}\n",
+      "{'financese.lcoe': array([0.03624933])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|3\n",
       "---------------------------------------------------------------\n",
@@ -309,25 +243,9 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([9.]),\n",
       " 'spacing_secondary': array([9.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.0362278])}\n",
+      "{'financese.lcoe': array([0.03617556])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|4\n",
       "---------------------------------------------------------------\n",
@@ -336,25 +254,9 @@
       " 'angle_skew': array([0.]),\n",
       " 'spacing_primary': array([9.]),\n",
       " 'spacing_secondary': array([9.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03589558])}\n",
+      "{'financese.lcoe': array([0.03584399])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|5\n",
       "---------------------------------------------------------------\n",
@@ -363,1332 +265,594 @@
       " 'angle_skew': array([2.]),\n",
       " 'spacing_primary': array([9.]),\n",
       " 'spacing_secondary': array([9.])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03576731])}\n",
+      "{'financese.lcoe': array([0.03571624])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|6\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([2.86507341]),\n",
-      " 'angle_skew': array([0.06342541]),\n",
-      " 'spacing_primary': array([9.88412296]),\n",
-      " 'spacing_secondary': array([7.42966507])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([2.86472678]),\n",
+      " 'angle_skew': array([0.06259902]),\n",
+      " 'spacing_primary': array([9.88434523]),\n",
+      " 'spacing_secondary': array([7.42956615])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03536135])}\n",
+      "{'financese.lcoe': array([0.03531047])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|7\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([6.22440279]),\n",
-      " 'angle_skew': array([1.28942792]),\n",
-      " 'spacing_primary': array([11.09600928]),\n",
-      " 'spacing_secondary': array([6.10937891])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:498\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([6.2249954]),\n",
+      " 'angle_skew': array([1.28482356]),\n",
+      " 'spacing_primary': array([11.09632306]),\n",
+      " 'spacing_secondary': array([6.10825176])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03370838])}\n",
+      "{'financese.lcoe': array([0.03366194])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|8\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([12.81065072]),\n",
-      " 'angle_skew': array([5.41443477]),\n",
-      " 'spacing_primary': array([10.77869556]),\n",
-      " 'spacing_secondary': array([4.23722274])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([12.81867001]),\n",
+      " 'angle_skew': array([5.39849156]),\n",
+      " 'spacing_primary': array([10.77914451]),\n",
+      " 'spacing_secondary': array([4.23726581])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03370143])}\n",
+      "{'financese.lcoe': array([0.03365148])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|9\n",
       "---------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([4.28310721]),\n",
-      " 'angle_skew': array([4.24611554]),\n",
-      " 'spacing_primary': array([11.15159215]),\n",
-      " 'spacing_secondary': array([4.24222055])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([15.16579535]),\n",
+      " 'angle_skew': array([2.65570238]),\n",
+      " 'spacing_primary': array([10.54973372]),\n",
+      " 'spacing_secondary': array([5.94474374])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03451831])}\n",
+      "{'financese.lcoe': array([0.03402733])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|10\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([6.00666884]),\n",
-      " 'angle_skew': array([1.33986207]),\n",
-      " 'spacing_primary': array([12.01188114]),\n",
-      " 'spacing_secondary': array([6.44288611])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([12.8345144]),\n",
+      " 'angle_skew': array([5.67717329]),\n",
+      " 'spacing_primary': array([11.57777225]),\n",
+      " 'spacing_secondary': array([4.77044418])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03373368])}\n",
+      "{'financese.lcoe': array([0.03354686])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|11\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.20718925]),\n",
-      " 'angle_skew': array([1.26618807]),\n",
-      " 'spacing_primary': array([11.04995437]),\n",
-      " 'spacing_secondary': array([5.85267537])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:498\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.06069203]),\n",
+      " 'angle_skew': array([5.12173355]),\n",
+      " 'spacing_primary': array([10.41709128]),\n",
+      " 'spacing_secondary': array([4.22986599])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03352562])}\n",
+      "{'financese.lcoe': array([0.03363844])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|12\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.30827026]),\n",
-      " 'angle_skew': array([-0.28110214]),\n",
-      " 'spacing_primary': array([11.21647279]),\n",
-      " 'spacing_secondary': array([4.60049836])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.13995264]),\n",
+      " 'angle_skew': array([4.71319936]),\n",
+      " 'spacing_primary': array([11.01527995]),\n",
+      " 'spacing_secondary': array([3.54503909])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03470472])}\n",
+      "{'financese.lcoe': array([0.03458857])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|13\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.29155102]),\n",
-      " 'angle_skew': array([0.64372952]),\n",
-      " 'spacing_primary': array([10.8322654]),\n",
-      " 'spacing_secondary': array([6.59969609])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.05906201]),\n",
+      " 'angle_skew': array([6.28573007]),\n",
+      " 'spacing_primary': array([9.42149182]),\n",
+      " 'spacing_secondary': array([5.51590298])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03362597])}\n",
+      "{'financese.lcoe': array([0.03410492])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|14\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.59086432]),\n",
-      " 'angle_skew': array([2.93175261]),\n",
-      " 'spacing_primary': array([10.37471801]),\n",
-      " 'spacing_secondary': array([6.64181672])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.06734214]),\n",
+      " 'angle_skew': array([5.12348552]),\n",
+      " 'spacing_primary': array([10.45650427]),\n",
+      " 'spacing_secondary': array([4.22920401])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03351144])}\n",
+      "{'financese.lcoe': array([0.03363728])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|15\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([9.75180855]),\n",
-      " 'angle_skew': array([3.5743247]),\n",
-      " 'spacing_primary': array([10.40303204]),\n",
-      " 'spacing_secondary': array([5.14565233])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.25674804]),\n",
+      " 'angle_skew': array([5.05925836]),\n",
+      " 'spacing_primary': array([10.45623439]),\n",
+      " 'spacing_secondary': array([4.22965665])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03362007])}\n",
+      "{'financese.lcoe': array([0.03365051])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|16\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.74175405]),\n",
-      " 'angle_skew': array([3.20209382]),\n",
-      " 'spacing_primary': array([9.87740784]),\n",
-      " 'spacing_secondary': array([7.45226753])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([14.09076211]),\n",
+      " 'angle_skew': array([5.19210329]),\n",
+      " 'spacing_primary': array([10.44835385]),\n",
+      " 'spacing_secondary': array([4.16081777])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03398983])}\n",
+      "{'financese.lcoe': array([0.03366734])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|17\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.69666884]),\n",
-      " 'angle_skew': array([2.95678515]),\n",
-      " 'spacing_primary': array([10.5780121]),\n",
-      " 'spacing_secondary': array([6.73851361])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.9731555]),\n",
+      " 'angle_skew': array([4.9478475]),\n",
+      " 'spacing_primary': array([10.47318285]),\n",
+      " 'spacing_secondary': array([4.23061394])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03350047])}\n",
+      "{'financese.lcoe': array([0.03361022])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|18\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.17818917]),\n",
-      " 'angle_skew': array([3.05428928]),\n",
-      " 'spacing_primary': array([10.45137129]),\n",
-      " 'spacing_secondary': array([6.39931257])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.90496297]),\n",
+      " 'angle_skew': array([4.88172646]),\n",
+      " 'spacing_primary': array([10.42062958]),\n",
+      " 'spacing_secondary': array([4.39858995])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.033564])}\n",
+      "{'financese.lcoe': array([0.03363528])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|19\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.54548368]),\n",
-      " 'angle_skew': array([2.85439181]),\n",
-      " 'spacing_primary': array([10.38776205]),\n",
-      " 'spacing_secondary': array([6.68407495])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.90080602]),\n",
+      " 'angle_skew': array([4.8790065]),\n",
+      " 'spacing_primary': array([10.47832507]),\n",
+      " 'spacing_secondary': array([4.23077813])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03351661])}\n",
+      "{'financese.lcoe': array([0.0335983])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|20\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.68235437]),\n",
-      " 'angle_skew': array([2.82528036]),\n",
-      " 'spacing_primary': array([10.38236737]),\n",
-      " 'spacing_secondary': array([6.49956794])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.7163965]),\n",
+      " 'angle_skew': array([4.80229897]),\n",
+      " 'spacing_primary': array([10.4887581]),\n",
+      " 'spacing_secondary': array([4.23126246])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03352674])}\n",
+      "{'financese.lcoe': array([0.03358231])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|21\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.6540565]),\n",
-      " 'angle_skew': array([2.91346029]),\n",
-      " 'spacing_primary': array([10.3196462]),\n",
-      " 'spacing_secondary': array([6.69319021])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.71595893]),\n",
+      " 'angle_skew': array([4.8020453]),\n",
+      " 'spacing_primary': array([10.47930893]),\n",
+      " 'spacing_secondary': array([4.22802869])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03351022])}\n",
+      "{'financese.lcoe': array([0.03358327])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|22\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.67575792]),\n",
-      " 'angle_skew': array([3.08481535]),\n",
-      " 'spacing_primary': array([10.2720701]),\n",
-      " 'spacing_secondary': array([6.78208906])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.72023935]),\n",
+      " 'angle_skew': array([4.79306721]),\n",
+      " 'spacing_primary': array([10.48880396]),\n",
+      " 'spacing_secondary': array([4.23133267])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03351441])}\n",
+      "{'financese.lcoe': array([0.03358165])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|23\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.84425874]),\n",
-      " 'angle_skew': array([3.07310244]),\n",
-      " 'spacing_primary': array([10.28009779]),\n",
-      " 'spacing_secondary': array([6.67529094])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.7203938]),\n",
+      " 'angle_skew': array([4.79307559]),\n",
+      " 'spacing_primary': array([10.49203488]),\n",
+      " 'spacing_secondary': array([4.22187026])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349585])}\n",
+      "{'financese.lcoe': array([0.03358269])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|24\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([9.18352292]),\n",
-      " 'angle_skew': array([3.04313706]),\n",
-      " 'spacing_primary': array([10.29713614]),\n",
-      " 'spacing_secondary': array([6.46621779])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.71380913]),\n",
+      " 'angle_skew': array([4.78035069]),\n",
+      " 'spacing_primary': array([10.48610853]),\n",
+      " 'spacing_secondary': array([4.245105])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03351251])}\n",
+      "{'financese.lcoe': array([0.03357842])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|25\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.84094657]),\n",
-      " 'angle_skew': array([3.23775271]),\n",
-      " 'spacing_primary': array([10.23836947]),\n",
-      " 'spacing_secondary': array([6.78082797])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.69777685]),\n",
+      " 'angle_skew': array([4.75473775]),\n",
+      " 'spacing_primary': array([10.48011045]),\n",
+      " 'spacing_secondary': array([4.27061904])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03350363])}\n",
+      "{'financese.lcoe': array([0.03357623])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|26\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.92780689]),\n",
-      " 'angle_skew': array([3.06227062]),\n",
-      " 'spacing_primary': array([10.28551011]),\n",
-      " 'spacing_secondary': array([6.62168977])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.73063005]),\n",
+      " 'angle_skew': array([4.7487034]),\n",
+      " 'spacing_primary': array([10.47275106]),\n",
+      " 'spacing_secondary': array([4.29135773])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349405])}\n",
+      "{'financese.lcoe': array([0.03357785])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|27\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.96908323]),\n",
-      " 'angle_skew': array([2.99969751]),\n",
-      " 'spacing_primary': array([10.26251137]),\n",
-      " 'spacing_secondary': array([6.68375367])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68202514]),\n",
+      " 'angle_skew': array([4.74561956]),\n",
+      " 'spacing_primary': array([10.47859155]),\n",
+      " 'spacing_secondary': array([4.27876983])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.0334977])}\n",
+      "{'financese.lcoe': array([0.03357592])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|28\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.92431437]),\n",
-      " 'angle_skew': array([3.06109607]),\n",
-      " 'spacing_primary': array([10.26197456]),\n",
-      " 'spacing_secondary': array([6.61410686])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68461032]),\n",
+      " 'angle_skew': array([4.72946958]),\n",
+      " 'spacing_primary': array([10.4831355]),\n",
+      " 'spacing_secondary': array([4.26819404])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349462])}\n",
+      "{'financese.lcoe': array([0.03357384])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|29\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.91563967]),\n",
-      " 'angle_skew': array([3.05174114]),\n",
-      " 'spacing_primary': array([10.29746973]),\n",
-      " 'spacing_secondary': array([6.57588523])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68237896]),\n",
+      " 'angle_skew': array([4.71506942]),\n",
+      " 'spacing_primary': array([10.48846385]),\n",
+      " 'spacing_secondary': array([4.25557401])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.0334975])}\n",
+      "{'financese.lcoe': array([0.0335716])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|30\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.93680565]),\n",
-      " 'angle_skew': array([3.06521408]),\n",
-      " 'spacing_primary': array([10.28505436]),\n",
-      " 'spacing_secondary': array([6.61850376])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67778694]),\n",
+      " 'angle_skew': array([4.68473807]),\n",
+      " 'spacing_primary': array([10.49855396]),\n",
+      " 'spacing_secondary': array([4.23197078])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349397])}\n",
+      "{'financese.lcoe': array([0.03357104])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|31\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.93541161]),\n",
-      " 'angle_skew': array([3.08299015]),\n",
-      " 'spacing_primary': array([10.28137613]),\n",
-      " 'spacing_secondary': array([6.62678257])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.66787709]),\n",
+      " 'angle_skew': array([4.67538831]),\n",
+      " 'spacing_primary': array([10.46094591]),\n",
+      " 'spacing_secondary': array([4.23207544])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349297])}\n",
+      "{'financese.lcoe': array([0.03357297])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|32\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.9414375]),\n",
-      " 'angle_skew': array([3.09048798]),\n",
-      " 'spacing_primary': array([10.27644142]),\n",
-      " 'spacing_secondary': array([6.64360874])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67618262]),\n",
+      " 'angle_skew': array([4.67931398]),\n",
+      " 'spacing_primary': array([10.5003476]),\n",
+      " 'spacing_secondary': array([4.2400199])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349228])}\n",
+      "{'financese.lcoe': array([0.03356904])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|33\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.94171468]),\n",
-      " 'angle_skew': array([3.10878737]),\n",
-      " 'spacing_primary': array([10.27276221]),\n",
-      " 'spacing_secondary': array([6.65078641])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.66831202]),\n",
+      " 'angle_skew': array([4.68726302]),\n",
+      " 'spacing_primary': array([10.50042123]),\n",
+      " 'spacing_secondary': array([4.23136768])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349156])}\n",
+      "{'financese.lcoe': array([0.03357112])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|34\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.97150949]),\n",
-      " 'angle_skew': array([3.13361962]),\n",
-      " 'spacing_primary': array([10.26586472]),\n",
-      " 'spacing_secondary': array([6.65771845])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67790999]),\n",
+      " 'angle_skew': array([4.68550449]),\n",
+      " 'spacing_primary': array([10.49833264]),\n",
+      " 'spacing_secondary': array([4.2325611])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03349054])}\n",
+      "{'financese.lcoe': array([0.03357096])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|35\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.97471229]),\n",
-      " 'angle_skew': array([3.16240794]),\n",
-      " 'spacing_primary': array([10.25667862]),\n",
-      " 'spacing_secondary': array([6.68372979])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67785364]),\n",
+      " 'angle_skew': array([4.68505868]),\n",
+      " 'spacing_primary': array([10.49771257]),\n",
+      " 'spacing_secondary': array([4.23440869])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.0334902])}\n",
+      "{'financese.lcoe': array([0.03357061])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|36\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.97294762]),\n",
-      " 'angle_skew': array([3.19266705]),\n",
-      " 'spacing_primary': array([10.25888031]),\n",
-      " 'spacing_secondary': array([6.65772162])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67793918]),\n",
+      " 'angle_skew': array([4.68426311]),\n",
+      " 'spacing_primary': array([10.49655202]),\n",
+      " 'spacing_secondary': array([4.23815206])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03348846])}\n",
+      "{'financese.lcoe': array([0.03356994])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|37\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.98282721]),\n",
-      " 'angle_skew': array([3.22341897]),\n",
-      " 'spacing_primary': array([10.25938009]),\n",
-      " 'spacing_secondary': array([6.63413215])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.6786557]),\n",
+      " 'angle_skew': array([4.68354482]),\n",
+      " 'spacing_primary': array([10.4941268]),\n",
+      " 'spacing_secondary': array([4.24570779])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03348738])}\n",
+      "{'financese.lcoe': array([0.03356983])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|38\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.98743922]),\n",
-      " 'angle_skew': array([3.26280778]),\n",
-      " 'spacing_primary': array([10.2542312]),\n",
-      " 'spacing_secondary': array([6.63499243])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67771374]),\n",
+      " 'angle_skew': array([4.68100995]),\n",
+      " 'spacing_primary': array([10.49135862]),\n",
+      " 'spacing_secondary': array([4.24469571])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03348601])}\n",
+      "{'financese.lcoe': array([0.03356977])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|39\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([9.00395892]),\n",
-      " 'angle_skew': array([3.34033783]),\n",
-      " 'spacing_primary': array([10.24352712]),\n",
-      " 'spacing_secondary': array([6.63626258])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67869541]),\n",
+      " 'angle_skew': array([4.67945733]),\n",
+      " 'spacing_primary': array([10.49213494]),\n",
+      " 'spacing_secondary': array([4.24484747])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03348343])}\n",
+      "{'financese.lcoe': array([0.03356946])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|40\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.93612225]),\n",
-      " 'angle_skew': array([3.48355345]),\n",
-      " 'spacing_primary': array([10.23731751]),\n",
-      " 'spacing_secondary': array([6.61507499])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67969515]),\n",
+      " 'angle_skew': array([4.67611596]),\n",
+      " 'spacing_primary': array([10.49401504]),\n",
+      " 'spacing_secondary': array([4.24539613])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03347882])}\n",
+      "{'financese.lcoe': array([0.03356848])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|41\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.95916329]),\n",
-      " 'angle_skew': array([3.80019775]),\n",
-      " 'spacing_primary': array([10.20307325]),\n",
-      " 'spacing_secondary': array([6.5942704])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68607364]),\n",
+      " 'angle_skew': array([4.67140637]),\n",
+      " 'spacing_primary': array([10.49503139]),\n",
+      " 'spacing_secondary': array([4.24507744])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346946])}\n",
+      "{'financese.lcoe': array([0.03356819])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|42\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.99875165]),\n",
-      " 'angle_skew': array([4.10069548]),\n",
-      " 'spacing_primary': array([10.27891273]),\n",
-      " 'spacing_secondary': array([6.03571669])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68279844]),\n",
+      " 'angle_skew': array([4.66437621]),\n",
+      " 'spacing_primary': array([10.49312488]),\n",
+      " 'spacing_secondary': array([4.24461354])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.0336019])}\n",
+      "{'financese.lcoe': array([0.03356762])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|43\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.89437289]),\n",
-      " 'angle_skew': array([3.82860692]),\n",
-      " 'spacing_primary': array([9.99398572]),\n",
-      " 'spacing_secondary': array([6.82595451])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68151852]),\n",
+      " 'angle_skew': array([4.65942861]),\n",
+      " 'spacing_primary': array([10.49423132]),\n",
+      " 'spacing_secondary': array([4.25066819])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03354543])}\n",
+      "{'financese.lcoe': array([0.03356681])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|44\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.95835196]),\n",
-      " 'angle_skew': array([3.8101481]),\n",
-      " 'spacing_primary': array([10.26271389]),\n",
-      " 'spacing_secondary': array([6.64664718])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68063247]),\n",
+      " 'angle_skew': array([4.65313933]),\n",
+      " 'spacing_primary': array([10.49318479]),\n",
+      " 'spacing_secondary': array([4.25541842])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346738])}\n",
+      "{'financese.lcoe': array([0.03356564])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|45\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.98227427]),\n",
-      " 'angle_skew': array([3.81532101]),\n",
-      " 'spacing_primary': array([10.2341381]),\n",
-      " 'spacing_secondary': array([6.43976427])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68340248]),\n",
+      " 'angle_skew': array([4.64975998]),\n",
+      " 'spacing_primary': array([10.48035301]),\n",
+      " 'spacing_secondary': array([4.26391856])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03348852])}\n",
+      "{'financese.lcoe': array([0.03356829])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|46\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.9197167]),\n",
-      " 'angle_skew': array([3.80310252]),\n",
-      " 'spacing_primary': array([10.20639718]),\n",
-      " 'spacing_secondary': array([6.58932262])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67644609]),\n",
+      " 'angle_skew': array([4.6465506]),\n",
+      " 'spacing_primary': array([10.49424633]),\n",
+      " 'spacing_secondary': array([4.25402704])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346921])}\n",
+      "{'financese.lcoe': array([0.03356515])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|47\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.90574977]),\n",
-      " 'angle_skew': array([3.82174101]),\n",
-      " 'spacing_primary': array([10.16655647]),\n",
-      " 'spacing_secondary': array([6.65466976])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.68003839]),\n",
+      " 'angle_skew': array([4.63941709]),\n",
+      " 'spacing_primary': array([10.4945764]),\n",
+      " 'spacing_secondary': array([4.25434244])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03347065])}\n",
+      "{'financese.lcoe': array([0.03356464])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|48\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.92178396]),\n",
-      " 'angle_skew': array([3.82244471]),\n",
-      " 'spacing_primary': array([10.20721649]),\n",
-      " 'spacing_secondary': array([6.58474715])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67914659]),\n",
+      " 'angle_skew': array([4.63196963]),\n",
+      " 'spacing_primary': array([10.49426086]),\n",
+      " 'spacing_secondary': array([4.25710659])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346877])}\n",
+      "{'financese.lcoe': array([0.03356389])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|49\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.91405197]),\n",
-      " 'angle_skew': array([3.85212766]),\n",
-      " 'spacing_primary': array([10.20908038]),\n",
-      " 'spacing_secondary': array([6.5591412])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67651851]),\n",
+      " 'angle_skew': array([4.61920423]),\n",
+      " 'spacing_primary': array([10.49234585]),\n",
+      " 'spacing_secondary': array([4.26618791])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346911])}\n",
+      "{'financese.lcoe': array([0.0335648])}\n",
       "\n",
       "Driver debug print for iter coord: rank0:ScipyOptimize_COBYLA|50\n",
       "----------------------------------------------------------------\n",
       "Design Vars\n",
-      "{'angle_orientation': array([8.92096623]),\n",
-      " 'angle_skew': array([3.82299027]),\n",
-      " 'spacing_primary': array([10.19726613]),\n",
-      " 'spacing_secondary': array([6.58490219])}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divide"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "{'angle_orientation': array([13.67643722]),\n",
+      " 'angle_skew': array([4.62963738]),\n",
+      " 'spacing_primary': array([10.48993342]),\n",
+      " 'spacing_secondary': array([4.25140631])}\n",
+      "\n",
       "Objectives\n",
-      "{'financese.lcoe': array([0.03346879])}\n",
+      "{'financese.lcoe': array([0.03356462])}\n",
       "\n",
       "Return from COBYLA because the objective function has been evaluated MAXFUN times.\n",
-      "Number of function values = 50   Least value of F = 0.03346878666309313   Constraint violation = 0.0\n",
+      "Number of function values = 50   Least value of F = 0.033563887643952524   Constraint violation = 0.0\n",
       "The corresponding X is:\n",
-      "[10.19726613  6.58490219  8.92096623  3.82299027]\n",
+      "[10.49426086  4.25710659 13.67914659  4.63196963]\n",
       "The constraint value is:\n",
-      "[-7.19726613e+00 -3.58490219e+00 -1.88920966e+02 -4.88229903e+01\n",
-      " -9.80273387e+00 -1.34150978e+01 -1.71079034e+02 -4.11770097e+01\n",
-      " -2.46831711e-01 -2.24161401e+00 -2.65275439e+00 -1.90045167e+00\n",
-      " -4.53271484e-03 -1.14008252e+00 -3.30539637e+00 -4.32637720e+00\n",
-      " -3.00226636e+00 -3.83049316e-01 -7.61565918e-01 -3.38078296e+00\n",
-      " -5.99999604e+00 -3.38078296e+00 -7.61565918e-01 -3.83049316e-01\n",
-      " -3.00226636e+00 -4.32637720e+00 -3.30539637e+00 -1.14008252e+00\n",
-      " -4.53271484e-03 -1.90045167e+00 -2.65275439e+00 -2.24161401e+00\n",
-      " -2.46831711e-01 -7.73644597e-01 -2.09928919e+00 -3.42493379e+00\n",
-      " -4.75057839e+00 -3.05946391e-01 -9.78275808e-01 -2.17968140e+00\n",
-      " -3.46011786e+00 -4.76276842e+00 -1.16389278e+00 -1.54521208e+00\n",
-      " -2.50855162e+00 -3.67296403e+00 -4.91136280e+00 -2.02183917e+00\n",
-      " -2.26349232e+00 -3.01787579e+00 -4.03882742e+00 -5.18577369e+00\n",
-      " -2.87978557e+00 -3.04353049e+00 -3.64242417e+00 -4.52473279e+00\n",
-      " -5.56910323e+00 -7.73644597e-01 -2.09928919e+00 -3.42493379e+00\n",
-      " -1.07436625e+00 -3.05946391e-01 -9.78275808e-01 -2.17968140e+00\n",
-      " -3.46011786e+00 -1.68517339e+00 -1.16389278e+00 -1.54521208e+00\n",
-      " -2.50855162e+00 -3.67296403e+00 -2.42070355e+00 -2.02183917e+00\n",
-      " -2.26349232e+00 -3.01787579e+00 -4.03882742e+00 -3.20846965e+00\n",
-      " -2.87978557e+00 -3.04353049e+00 -3.64242417e+00 -4.52473279e+00\n",
-      " -7.73644597e-01 -2.09928919e+00 -2.28855092e+00 -1.07436625e+00\n",
-      " -3.05946391e-01 -9.78275808e-01 -2.17968140e+00 -2.70073249e+00\n",
-      " -1.68517339e+00 -1.16389278e+00 -1.54521208e+00 -2.50855162e+00\n",
-      " -3.26427460e+00 -2.42070355e+00 -2.02183917e+00 -2.26349232e+00\n",
-      " -3.01787579e+00 -3.92234677e+00 -3.20846965e+00 -2.87978557e+00\n",
-      " -3.04353049e+00 -3.64242417e+00 -7.73644597e-01 -3.57196157e+00\n",
-      " -2.28855092e+00 -1.07436625e+00 -3.05946391e-01 -9.78275808e-01\n",
-      " -3.88311666e+00 -2.70073249e+00 -1.68517339e+00 -1.16389278e+00\n",
-      " -1.54521208e+00 -4.32709874e+00 -3.26427460e+00 -2.42070355e+00\n",
-      " -2.02183917e+00 -2.26349232e+00 -4.87138393e+00 -3.92234677e+00\n",
-      " -3.20846965e+00 -2.87978557e+00 -3.04353049e+00 -4.87571184e+00\n",
-      " -3.57196157e+00 -2.28855092e+00 -1.07436625e+00 -3.05946391e-01\n",
-      " -5.12910184e+00 -3.88311666e+00 -2.70073249e+00 -1.68517339e+00\n",
-      " -1.16389278e+00 -5.49464571e+00 -4.32709874e+00 -3.26427460e+00\n",
-      " -2.42070355e+00 -2.02183917e+00 -5.95346498e+00 -4.87138393e+00\n",
-      " -3.92234677e+00 -3.20846965e+00 -2.87978557e+00 -7.73644597e-01\n",
-      " -2.09928919e+00 -3.42493379e+00 -4.75057839e+00 -3.05946391e-01\n",
-      " -9.78275808e-01 -2.17968140e+00 -3.46011786e+00 -4.76276842e+00\n",
-      " -1.16389278e+00 -1.54521208e+00 -2.50855162e+00 -3.67296403e+00\n",
-      " -4.91136280e+00 -2.02183917e+00 -2.26349232e+00 -3.01787579e+00\n",
-      " -4.03882742e+00 -5.18577369e+00 -7.73644597e-01 -2.09928919e+00\n",
-      " -3.42493379e+00 -1.07436625e+00 -3.05946391e-01 -9.78275808e-01\n",
-      " -2.17968140e+00 -3.46011786e+00 -1.68517339e+00 -1.16389278e+00\n",
-      " -1.54521208e+00 -2.50855162e+00 -3.67296403e+00 -2.42070355e+00\n",
-      " -2.02183917e+00 -2.26349232e+00 -3.01787579e+00 -4.03882742e+00\n",
-      " -7.73644597e-01 -2.09928919e+00 -2.28855092e+00 -1.07436625e+00\n",
-      " -3.05946391e-01 -9.78275808e-01 -2.17968140e+00 -2.70073249e+00\n",
-      " -1.68517339e+00 -1.16389278e+00 -1.54521208e+00 -2.50855162e+00\n",
-      " -3.26427460e+00 -2.42070355e+00 -2.02183917e+00 -2.26349232e+00\n",
-      " -3.01787579e+00 -7.73644597e-01 -3.57196157e+00 -2.28855092e+00\n",
-      " -1.07436625e+00 -3.05946391e-01 -9.78275808e-01 -3.88311666e+00\n",
-      " -2.70073249e+00 -1.68517339e+00 -1.16389278e+00 -1.54521208e+00\n",
-      " -4.32709874e+00 -3.26427460e+00 -2.42070355e+00 -2.02183917e+00\n",
-      " -2.26349232e+00 -4.87571184e+00 -3.57196157e+00 -2.28855092e+00\n",
-      " -1.07436625e+00 -3.05946391e-01 -5.12910184e+00 -3.88311666e+00\n",
-      " -2.70073249e+00 -1.68517339e+00 -1.16389278e+00 -5.49464571e+00\n",
-      " -4.32709874e+00 -3.26427460e+00 -2.42070355e+00 -2.02183917e+00\n",
-      " -7.73644597e-01 -2.09928919e+00 -3.42493379e+00 -4.75057839e+00\n",
-      " -3.05946391e-01 -9.78275808e-01 -2.17968140e+00 -3.46011786e+00\n",
-      " -4.76276842e+00 -1.16389278e+00 -1.54521208e+00 -2.50855162e+00\n",
-      " -3.67296403e+00 -4.91136280e+00 -7.73644597e-01 -2.09928919e+00\n",
-      " -3.42493379e+00 -1.07436625e+00 -3.05946391e-01 -9.78275808e-01\n",
-      " -2.17968140e+00 -3.46011786e+00 -1.68517339e+00 -1.16389278e+00\n",
-      " -1.54521208e+00 -2.50855162e+00 -3.67296403e+00 -7.73644597e-01\n",
-      " -2.09928919e+00 -2.28855092e+00 -1.07436625e+00 -3.05946391e-01\n",
-      " -9.78275808e-01 -2.17968140e+00 -2.70073249e+00 -1.68517339e+00\n",
-      " -1.16389278e+00 -1.54521208e+00 -2.50855162e+00 -7.73644597e-01\n",
-      " -3.57196157e+00 -2.28855092e+00 -1.07436625e+00 -3.05946391e-01\n",
-      " -9.78275808e-01 -3.88311666e+00 -2.70073249e+00 -1.68517339e+00\n",
-      " -1.16389278e+00 -1.54521208e+00 -4.87571184e+00 -3.57196157e+00\n",
-      " -2.28855092e+00 -1.07436625e+00 -3.05946391e-01 -5.12910184e+00\n",
-      " -3.88311666e+00 -2.70073249e+00 -1.68517339e+00 -1.16389278e+00\n",
-      " -7.73644597e-01 -2.09928919e+00 -3.42493379e+00 -4.75057839e+00\n",
-      " -3.05946391e-01 -9.78275808e-01 -2.17968140e+00 -3.46011786e+00\n",
-      " -4.76276842e+00 -7.73644597e-01 -2.09928919e+00 -3.42493379e+00\n",
-      " -1.07436625e+00 -3.05946391e-01 -9.78275808e-01 -2.17968140e+00\n",
-      " -3.46011786e+00 -7.73644597e-01 -2.09928919e+00 -2.28855092e+00\n",
-      " -1.07436625e+00 -3.05946391e-01 -9.78275808e-01 -2.17968140e+00\n",
-      " -7.73644597e-01 -3.57196157e+00 -2.28855092e+00 -1.07436625e+00\n",
-      " -3.05946391e-01 -9.78275808e-01 -4.87571184e+00 -3.57196157e+00\n",
-      " -2.28855092e+00 -1.07436625e+00 -3.05946391e-01 -7.73644597e-01\n",
-      " -2.09928919e+00 -3.42493379e+00 -4.75057839e+00 -7.73644597e-01\n",
-      " -2.09928919e+00 -3.42493379e+00 -7.73644597e-01 -2.09928919e+00\n",
-      " -7.73644597e-01]\n",
+      "[-7.49426086e+00 -1.25710659e+00 -1.93679147e+02 -4.96319696e+01\n",
+      " -9.50573914e+00 -1.57428934e+01 -1.66320853e+02 -4.03680304e+01\n",
+      " -7.04668506e-01 -3.03554985e+00 -3.89150977e+00 -2.65111523e+00\n",
+      " -9.76562500e-07 -1.04665625e+00 -3.53431468e+00 -4.94575488e+00\n",
+      " -3.00000049e+00 -3.48886230e-01 -6.97770996e-01 -3.34888550e+00\n",
+      " -5.99999604e+00 -3.34888550e+00 -6.97770996e-01 -3.48886230e-01\n",
+      " -3.00000049e+00 -4.94575488e+00 -3.53431468e+00 -1.04665625e+00\n",
+      " -9.76562500e-07 -2.65111523e+00 -3.89150977e+00 -3.03554985e+00\n",
+      " -7.04668506e-01 -8.12253911e-01 -2.17650782e+00 -3.54076173e+00\n",
+      " -4.90501565e+00 -3.23727596e-03 -8.78781496e-01 -2.18813876e+00\n",
+      " -3.53357984e+00 -4.88839909e+00 -5.58474552e-01 -1.13609345e+00\n",
+      " -2.30956299e+00 -3.60128827e+00 -4.92827752e+00 -1.11371183e+00\n",
+      " -1.51409782e+00 -2.52782174e+00 -3.74034449e+00 -5.02343881e+00\n",
+      " -1.66894910e+00 -1.95886394e+00 -2.82418691e+00 -3.94413343e+00\n",
+      " -5.17112598e+00 -8.12253911e-01 -2.17650782e+00 -3.54076173e+00\n",
+      " -9.61875373e-01 -3.23727596e-03 -8.78781496e-01 -2.18813876e+00\n",
+      " -3.53357984e+00 -1.27530004e+00 -5.58474552e-01 -1.13609345e+00\n",
+      " -2.30956299e+00 -3.60128827e+00 -1.68469601e+00 -1.11371183e+00\n",
+      " -1.51409782e+00 -2.52782174e+00 -3.74034449e+00 -2.14673481e+00\n",
+      " -1.66894910e+00 -1.95886394e+00 -2.82418691e+00 -3.94413343e+00\n",
+      " -8.12253911e-01 -2.17650782e+00 -2.27602516e+00 -9.61875373e-01\n",
+      " -3.23727596e-03 -8.78781496e-01 -2.18813876e+00 -2.47575075e+00\n",
+      " -1.27530004e+00 -5.58474552e-01 -1.13609345e+00 -2.30956299e+00\n",
+      " -2.75759207e+00 -1.68469601e+00 -1.11371183e+00 -1.51409782e+00\n",
+      " -2.52782174e+00 -3.10260007e+00 -2.14673481e+00 -1.66894910e+00\n",
+      " -1.95886394e+00 -2.82418691e+00 -8.12253911e-01 -3.62244745e+00\n",
+      " -2.27602516e+00 -9.61875373e-01 -3.23727596e-03 -8.78781496e-01\n",
+      " -3.77441898e+00 -2.47575075e+00 -1.27530004e+00 -5.58474552e-01\n",
+      " -1.13609345e+00 -3.98962612e+00 -2.75759207e+00 -1.68469601e+00\n",
+      " -1.11371183e+00 -1.51409782e+00 -4.25959134e+00 -3.10260007e+00\n",
+      " -2.14673481e+00 -1.66894910e+00 -1.95886394e+00 -4.97761790e+00\n",
+      " -3.62244745e+00 -2.27602516e+00 -9.61875373e-01 -3.23727596e-03\n",
+      " -5.10405033e+00 -3.77441898e+00 -2.47575075e+00 -1.27530004e+00\n",
+      " -5.58474552e-01 -5.28081350e+00 -3.98962612e+00 -2.75759207e+00\n",
+      " -1.68469601e+00 -1.11371183e+00 -5.50350149e+00 -4.25959134e+00\n",
+      " -3.10260007e+00 -2.14673481e+00 -1.66894910e+00 -8.12253911e-01\n",
+      " -2.17650782e+00 -3.54076173e+00 -4.90501565e+00 -3.23727596e-03\n",
+      " -8.78781496e-01 -2.18813876e+00 -3.53357984e+00 -4.88839909e+00\n",
+      " -5.58474552e-01 -1.13609345e+00 -2.30956299e+00 -3.60128827e+00\n",
+      " -4.92827752e+00 -1.11371183e+00 -1.51409782e+00 -2.52782174e+00\n",
+      " -3.74034449e+00 -5.02343881e+00 -8.12253911e-01 -2.17650782e+00\n",
+      " -3.54076173e+00 -9.61875373e-01 -3.23727596e-03 -8.78781496e-01\n",
+      " -2.18813876e+00 -3.53357984e+00 -1.27530004e+00 -5.58474552e-01\n",
+      " -1.13609345e+00 -2.30956299e+00 -3.60128827e+00 -1.68469601e+00\n",
+      " -1.11371183e+00 -1.51409782e+00 -2.52782174e+00 -3.74034449e+00\n",
+      " -8.12253911e-01 -2.17650782e+00 -2.27602516e+00 -9.61875373e-01\n",
+      " -3.23727596e-03 -8.78781496e-01 -2.18813876e+00 -2.47575075e+00\n",
+      " -1.27530004e+00 -5.58474552e-01 -1.13609345e+00 -2.30956299e+00\n",
+      " -2.75759207e+00 -1.68469601e+00 -1.11371183e+00 -1.51409782e+00\n",
+      " -2.52782174e+00 -8.12253911e-01 -3.62244745e+00 -2.27602516e+00\n",
+      " -9.61875373e-01 -3.23727596e-03 -8.78781496e-01 -3.77441898e+00\n",
+      " -2.47575075e+00 -1.27530004e+00 -5.58474552e-01 -1.13609345e+00\n",
+      " -3.98962612e+00 -2.75759207e+00 -1.68469601e+00 -1.11371183e+00\n",
+      " -1.51409782e+00 -4.97761790e+00 -3.62244745e+00 -2.27602516e+00\n",
+      " -9.61875373e-01 -3.23727596e-03 -5.10405033e+00 -3.77441898e+00\n",
+      " -2.47575075e+00 -1.27530004e+00 -5.58474552e-01 -5.28081350e+00\n",
+      " -3.98962612e+00 -2.75759207e+00 -1.68469601e+00 -1.11371183e+00\n",
+      " -8.12253911e-01 -2.17650782e+00 -3.54076173e+00 -4.90501565e+00\n",
+      " -3.23727596e-03 -8.78781496e-01 -2.18813876e+00 -3.53357984e+00\n",
+      " -4.88839909e+00 -5.58474552e-01 -1.13609345e+00 -2.30956299e+00\n",
+      " -3.60128827e+00 -4.92827752e+00 -8.12253911e-01 -2.17650782e+00\n",
+      " -3.54076173e+00 -9.61875373e-01 -3.23727596e-03 -8.78781496e-01\n",
+      " -2.18813876e+00 -3.53357984e+00 -1.27530004e+00 -5.58474552e-01\n",
+      " -1.13609345e+00 -2.30956299e+00 -3.60128827e+00 -8.12253911e-01\n",
+      " -2.17650782e+00 -2.27602516e+00 -9.61875373e-01 -3.23727596e-03\n",
+      " -8.78781496e-01 -2.18813876e+00 -2.47575075e+00 -1.27530004e+00\n",
+      " -5.58474552e-01 -1.13609345e+00 -2.30956299e+00 -8.12253911e-01\n",
+      " -3.62244745e+00 -2.27602516e+00 -9.61875373e-01 -3.23727596e-03\n",
+      " -8.78781496e-01 -3.77441898e+00 -2.47575075e+00 -1.27530004e+00\n",
+      " -5.58474552e-01 -1.13609345e+00 -4.97761790e+00 -3.62244745e+00\n",
+      " -2.27602516e+00 -9.61875373e-01 -3.23727596e-03 -5.10405033e+00\n",
+      " -3.77441898e+00 -2.47575075e+00 -1.27530004e+00 -5.58474552e-01\n",
+      " -8.12253911e-01 -2.17650782e+00 -3.54076173e+00 -4.90501565e+00\n",
+      " -3.23727596e-03 -8.78781496e-01 -2.18813876e+00 -3.53357984e+00\n",
+      " -4.88839909e+00 -8.12253911e-01 -2.17650782e+00 -3.54076173e+00\n",
+      " -9.61875373e-01 -3.23727596e-03 -8.78781496e-01 -2.18813876e+00\n",
+      " -3.53357984e+00 -8.12253911e-01 -2.17650782e+00 -2.27602516e+00\n",
+      " -9.61875373e-01 -3.23727596e-03 -8.78781496e-01 -2.18813876e+00\n",
+      " -8.12253911e-01 -3.62244745e+00 -2.27602516e+00 -9.61875373e-01\n",
+      " -3.23727596e-03 -8.78781496e-01 -4.97761790e+00 -3.62244745e+00\n",
+      " -2.27602516e+00 -9.61875373e-01 -3.23727596e-03 -8.12253911e-01\n",
+      " -2.17650782e+00 -3.54076173e+00 -4.90501565e+00 -8.12253911e-01\n",
+      " -2.17650782e+00 -3.54076173e+00 -8.12253911e-01 -2.17650782e+00\n",
+      " -8.12253911e-01]\n",
       "\n",
       "Optimization FAILED.\n",
       "Return from COBYLA because the objective function has been evaluated MAXFUN times.\n",
@@ -1697,14 +861,14 @@
       "\n",
       "RESULTS (opt):\n",
       "\n",
-      "{'AEP_val': 453.31177490509094,\n",
-      " 'BOS_val': 41.923934482221036,\n",
+      "{'AEP_val': 449.67167461051525,\n",
+      " 'BOS_val': 40.87410354289458,\n",
       " 'CapEx_val': 110.5,\n",
-      " 'LCOE_val': 33.46878666309313,\n",
+      " 'LCOE_val': 33.56461751519039,\n",
       " 'OpEx_val': 3.7400000000000007,\n",
-      " 'area_tight': 18.15681922585348,\n",
-      " 'coll_length': 23.423806992035267,\n",
-      " 'turbine_spacing': 0.8579463914778505}\n",
+      " 'area_tight': 12.059020447125771,\n",
+      " 'coll_length': 18.064954745483238,\n",
+      " 'turbine_spacing': 0.5544919826485551}\n",
       "\n",
       "\n",
       "\n"
@@ -1751,7 +915,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1777,6 +941,14 @@
    "source": [
     "The result: a farm that fits in a stop-sign domain and minimzes the LCOE."
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f65d53cc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/test/system/ard/api/inputs_offshore_floating/ard_system.yaml b/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
index 1a62e96e..b9f47aaa 100644
--- a/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
+++ b/test/system/ard/api/inputs_offshore_floating/ard_system.yaml
@@ -1,6 +1,7 @@
 system: "offshore_floating"
 
 modeling_options:
+  case_name: "LCOE_OFL"
   windIO_plant:
     name: "OFL system test plant"
     site:
diff --git a/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml b/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
index 7b8bcc12..7ae376b7 100644
--- a/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
+++ b/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
@@ -1,6 +1,7 @@
 system: "offshore_monopile"
 
 modeling_options:
+  case_name: "LCOE_OFB"
   windIO_plant:
     name: "OFB system test plant"
     site:
diff --git a/test/system/ard/api/inputs_onshore/ard_system.yaml b/test/system/ard/api/inputs_onshore/ard_system.yaml
index c7587536..517560e5 100644
--- a/test/system/ard/api/inputs_onshore/ard_system.yaml
+++ b/test/system/ard/api/inputs_onshore/ard_system.yaml
@@ -1,6 +1,7 @@
 system: "onshore"
 
 modeling_options:
+  case_name: "LCOE_LB"
   windIO_plant:
     name: "LB system test plant"
     site:
diff --git a/test/system/ard/api/test_LCOE_LB_stack.py b/test/system/ard/api/test_LCOE_LB_stack.py
index f9b2e3a8..4346bad5 100644
--- a/test/system/ard/api/test_LCOE_LB_stack.py
+++ b/test/system/ard/api/test_LCOE_LB_stack.py
@@ -28,6 +28,12 @@ def setup_method(self):
             input_dict=input_dict, root_data_path="inputs_onshore"
         )
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_model(self, subtests):
 
         # run the model
diff --git a/test/system/ard/api/test_LCOE_OFB_stack.py b/test/system/ard/api/test_LCOE_OFB_stack.py
index d81223c4..91b12571 100644
--- a/test/system/ard/api/test_LCOE_OFB_stack.py
+++ b/test/system/ard/api/test_LCOE_OFB_stack.py
@@ -31,6 +31,12 @@ def setup_method(self):
             input_dict=input_dict, root_data_path="inputs_onshore"
         )
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_model(self, subtests):
 
         # set up the working/design variables
diff --git a/test/system/ard/api/test_LCOE_OFL_stack.py b/test/system/ard/api/test_LCOE_OFL_stack.py
index e96c9b05..8e1c5583 100644
--- a/test/system/ard/api/test_LCOE_OFL_stack.py
+++ b/test/system/ard/api/test_LCOE_OFL_stack.py
@@ -18,7 +18,7 @@ def setup_method(self):
 
         # load the Ard system input
         path_ard_system = (
-            Path(__file__).parent / "inputs_offshore_monopile" / "ard_system.yaml"
+            Path(__file__).parent / "inputs_offshore_floating" / "ard_system.yaml"
         )
         input_dict = load_yaml(path_ard_system)
 
@@ -31,6 +31,12 @@ def setup_method(self):
             input_dict=input_dict, root_data_path="inputs_onshore"
         )
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_model(self, subtests):
 
         # set up the working/design variables
diff --git a/test/system/ard/api/test_LCOE_OFL_stack_pyrite.npz b/test/system/ard/api/test_LCOE_OFL_stack_pyrite.npz
index ddca2d93c541ab4888f6bb9533c049fffe22001c..c30bd65f53ceb840b0f5ff76cd61a82f0741332d 100644
GIT binary patch
delta 125
zcmbQjHHAwkz?+#xmjMD48Tbub3MUG!X4~n#<(mEViHEPVocXwI&g6NFtJxj$zs0Sz
zOPCzMbd{xg#k5V6HJR7QTzYrz;e#nr4gubbOuEdd=1l&`TmaGjky&hVHA^H!+dLMr
I$?sUy0JNtq%>V!Z

delta 125
zcmbQjHHAwkz?+#xmjMD485oUkeV!<^noah+a~Q|PiHEPV+`YMa%j9{CtJ!b&3l+T4
zNt_(Obd@FQ?)&|dHJR7Qg!pn#S${0TA;6oFNtYSboXH=V3n1D*GK)>FW{HGoo5vzH
I`5lWI09fiR3IG5A

diff --git a/test/system/ard/api/test_interface.py b/test/system/ard/api/test_interface.py
index 4938c646..94fc18e2 100644
--- a/test/system/ard/api/test_interface.py
+++ b/test/system/ard/api/test_interface.py
@@ -16,6 +16,12 @@ def setup_method(self):
 
         self.prob.run_model()
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_onshore_default_system_aep(self, subtests):
         with subtests.test("AEP_farm"):
             assert self.prob.get_val("AEP_farm", units="GW*h")[0] == pytest.approx(
@@ -58,6 +64,12 @@ def setup_method(self):
 
         self.prob.run_model()
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_offshore_monopile_default_system(self, subtests):
 
         with subtests.test("AEP_farm"):
@@ -97,6 +109,12 @@ def setup_method(self):
 
         self.prob.run_model()
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.prob.cleanup()
+        # necessary due to something about windows???
+
     def test_offshore_floating_default_system(self, subtests):
 
         with subtests.test("AEP_farm"):
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
index 78ddf085..c83d5e48 100644
--- a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
+++ b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
@@ -1,4 +1,5 @@
 modeling_options: &modeling_options
+  case_name: test_multiobjective
   windIO_plant: !include windio.yaml
   layout:
       type: gridfarm
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/unit/ard/api/test_multiobjective.py
index b3980256..0acd2da5 100644
--- a/test/unit/ard/api/test_multiobjective.py
+++ b/test/unit/ard/api/test_multiobjective.py
@@ -21,6 +21,12 @@ def setup_method(self):
             input_dict=input_dict,
         )
 
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.da_plough.cleanup()
+        # necessary due to final_setup() call below?
+
     def test_response_variables(self, subtests):
 
         # preemptively run the final setup

From df0ef37eb9a24cd96f65178cd868f4819878833b Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Wed, 17 Dec 2025 16:57:54 -0700
Subject: [PATCH 06/30] Bugfix/optiwindnet jitter overlapping (#163)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* updated tests to check jitter

* address comments from copilot

* add substation test

* deal with jared's comments

* black reformat and adding comments jared asked for

* added convenience printing to test.

* final black reformatting

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 ard/api/interface.py                         |   1 -
 ard/collection/optiwindnet_wrap.py           |  53 +++
 test/unit/ard/api/test_multiobjective.py     |   2 -
 test/unit/ard/collection/test_optiwindnet.py | 347 ++++++++++++++++++-
 4 files changed, 398 insertions(+), 5 deletions(-)

diff --git a/ard/api/interface.py b/ard/api/interface.py
index 88950d07..40a795db 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -1,4 +1,3 @@
-from pathlib import Path
 import importlib
 import openmdao.api as om
 from openmdao.drivers.doe_driver import DOEGenerator
diff --git a/ard/collection/optiwindnet_wrap.py b/ard/collection/optiwindnet_wrap.py
index f2cbb4e6..fad464a1 100644
--- a/ard/collection/optiwindnet_wrap.py
+++ b/ard/collection/optiwindnet_wrap.py
@@ -1,3 +1,5 @@
+from warnings import warn
+
 import networkx as nx
 import numpy as np
 
@@ -10,6 +12,7 @@
 
 
 def _own_L_from_inputs(inputs: dict, discrete_inputs: dict) -> nx.Graph:
+    # get the metadata and data for the OWN warm-starter from the inputs
     T = len(inputs["x_turbines"])
     R = len(inputs["x_substations"])
     name_case = "farm"
@@ -22,6 +25,54 @@ def _own_L_from_inputs(inputs: dict, discrete_inputs: dict) -> nx.Graph:
     VertexC[:T, 1] = inputs["y_turbines"]
     VertexC[-R:, 0] = inputs["x_substations"]
     VertexC[-R:, 1] = inputs["y_substations"]
+
+    # add perturbation to duplicate turbine/substation positions
+    VertexCTR = np.vstack([VertexC[:T, :], VertexC[-R:, :]])
+    perturbation_eps = 1.0e-6  # base magnitude of perturbation in m
+    perturbation_normal = np.array([-1.0, 1.0])  # set a fixed axis to perturb on
+    perturbation_normal = perturbation_normal / np.sqrt(
+        np.sum(perturbation_normal**2)
+    )  # normalize the perturbation
+    # go through the turbine/substation vertices and count how many times a
+    # given vertex has appeared before
+    repeat_accumulate = np.array(
+        [
+            int(np.sum(np.all(VertexCTR[:ivv, :] == vv, axis=1)))
+            for ivv, vv in enumerate(VertexCTR)
+        ]
+    )
+    if np.any(repeat_accumulate > 0):  # only if there are any repeats
+        warn_string = (
+            f"\nDetected {np.sum(repeat_accumulate > 0)} coincident "
+            f"turbines and/or substations in optiwindnet setup."
+        )  # start a warning string for the UserWarning
+        # TODO: make Ard warnings?
+
+        # create perturbation adjustements s.t. vertices w/ multiplicity > 2
+        # are adjusted to be fully unique!
+        adjustments = perturbation_eps * np.outer(
+            repeat_accumulate, perturbation_normal
+        )
+        # for each adjustments add to the warning string
+        for idx, dxy in enumerate(adjustments[:T, :]):
+            if np.sum(dxy != 0) == 0:
+                continue
+            warn_string += f"\n\tadjusting turbine #{idx} from {VertexCTR[idx, :]} to  {VertexCTR[idx, :] + dxy}"
+        for idx, dxy in enumerate((adjustments[-R:, :])[::-1, :]):
+            if np.sum(dxy != 0) == 0:
+                continue
+            warn_string += f"\n\tadjusting substation #{idx} from {VertexCTR[-(idx+1), :]} to {VertexCTR[-(idx+1), :] + dxy}"
+        # output the final warning
+        warn(warn_string)
+
+        # store the adjustments
+        VertexCTR += adjustments
+
+    # apply the adjustments
+    VertexC[:T, :] = VertexCTR[:T, :]
+    VertexC[-R:, :] = VertexCTR[-R:, :]
+
+    # put together the inputs for optiwindnet
     site = dict(
         T=T,
         R=R,
@@ -29,6 +80,8 @@ def _own_L_from_inputs(inputs: dict, discrete_inputs: dict) -> nx.Graph:
         handle=name_case,
         VertexC=VertexC,
     )
+
+    # handle the boundary if it exists
     if B > 0:
         VertexC[T:-R, 0] = discrete_inputs["x_border"]
         VertexC[T:-R, 1] = discrete_inputs["y_border"]
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/unit/ard/api/test_multiobjective.py
index 0acd2da5..7260acb3 100644
--- a/test/unit/ard/api/test_multiobjective.py
+++ b/test/unit/ard/api/test_multiobjective.py
@@ -1,7 +1,5 @@
 from pathlib import Path
 
-import openmdao.api as om
-
 from ard.utils.io import load_yaml
 from ard.api import set_up_ard_model
 
diff --git a/test/unit/ard/collection/test_optiwindnet.py b/test/unit/ard/collection/test_optiwindnet.py
index 7a58c001..ac9606d2 100644
--- a/test/unit/ard/collection/test_optiwindnet.py
+++ b/test/unit/ard/collection/test_optiwindnet.py
@@ -1,9 +1,8 @@
 import copy
 from pathlib import Path
-import platform, sys
+import warnings
 
 import numpy as np
-import matplotlib.pyplot as plt
 import openmdao.api as om
 from openmdao.utils.assert_utils import assert_check_partials
 
@@ -395,3 +394,347 @@ def test_compute_partials_mini_line(self):
         # automated OpenMDAO fails because it re-runs the network work
         cpJ = prob.check_partials(out_stream=None)
         assert_check_partials(cpJ, atol=1.0e-5, rtol=1.0e-3)
+
+
+class TestOptiWindNetCollection4TurbinesOverlap:
+
+    def setup_method(self):
+        self.n_turbines = 4
+        self.x_turbines = 7.0 * 130.0 * np.array([-1.0, 0.0, 0.0, 1.0])
+        self.y_turbines = 7.0 * 130.0 * np.array([-1.0, 0.0, 0.0, 1.0])
+        self.x_substations = np.array([-100.0])
+        self.y_substations = np.array([100.0])
+        self.modeling_options = make_modeling_options(
+            self.x_turbines,
+            self.y_turbines,
+            self.x_substations,
+            self.y_substations,
+        )
+
+        # create the OpenMDAO model
+        model = om.Group()
+        self.collection = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=self.modeling_options,
+            ),
+        )
+
+        self.prob = om.Problem(model)
+        self.prob.setup()
+
+    def test_perturbation_and_warning(self, subtests):
+        """
+        Test that OptiwindnetCollection issues a warning when turbines and/or substations
+        have coincident coordinates, but still produces valid results.
+
+        This test verifies that:
+        1. A warning is raised matching the pattern about coincident turbines/substations
+        2. The model still executes successfully despite the warning
+        3. The calculated total cable length matches the expected reference value
+        """
+
+        # deep copy modeling options and adjust
+        modeling_options = self.modeling_options
+
+        # create the OpenMDAO model
+        model = om.Group()
+        collection_mini = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=modeling_options,
+            ),
+        )
+
+        prob = om.Problem(model)
+        prob.setup()
+
+        prob.set_val("collection.x_turbines", self.x_turbines)
+        prob.set_val("collection.y_turbines", self.y_turbines)
+        prob.set_val("collection.x_substations", self.x_substations)
+        prob.set_val("collection.y_substations", self.y_substations)
+
+        with subtests.test("warn on duplicate turbine"):
+            with pytest.warns(
+                match=r"coincident turbines and/or substations in optiwindnet setup"
+            ) as warning:
+                # run optiwindnet
+                prob.run_model()
+                for w in warning:
+                    print(w.message)
+
+        # make sure that it still runs and we match a reference value
+        total_length_cables_reference = 2715.29003976
+        with subtests.test("match reference value"):
+            assert np.isclose(
+                prob.get_val("collection.total_length_cables"),
+                total_length_cables_reference,
+            )
+
+        # make sure the values in the optiwindnet graph are each close to a
+        # turbine but also include perturbation where it should be
+        T = collection_mini.graph.graph["T"]
+        R = collection_mini.graph.graph["R"]
+        VertexC = np.array(collection_mini.graph.graph["VertexC"])
+
+        for idx_T, xy_VertexCT in enumerate(VertexC[:T]):
+            # check if this turbine coordinate matches a turbine position (exactly or with perturbation)
+            matches_exactly = np.any(
+                np.logical_and(
+                    xy_VertexCT[0] == self.x_turbines,
+                    xy_VertexCT[1] == self.y_turbines,
+                )
+            )
+            matches_with_perturbation = np.any(
+                np.logical_and(
+                    np.isclose(xy_VertexCT[0], self.x_turbines, atol=1e-2)
+                    & (xy_VertexCT[0] != self.x_turbines),
+                    np.isclose(xy_VertexCT[1], self.y_turbines, atol=1e-2)
+                    & (xy_VertexCT[1] != self.y_turbines),
+                )
+            )
+            with subtests.test(f"turbine {idx_T} exact xor perturbed"):
+                assert matches_exactly ^ matches_with_perturbation  # boolean xor
+
+        for xy_VertexCR in VertexC[-R:]:
+            # check if this turbine coordinate matches a turbine position (exactly or with perturbation)
+            matches_exactly = np.any(
+                np.logical_and(
+                    xy_VertexCR[0] == self.x_substations,
+                    xy_VertexCR[1] == self.y_substations,
+                )
+            )
+            matches_with_perturbation = np.any(
+                np.logical_and(
+                    np.isclose(xy_VertexCR[0], self.x_substations, atol=1e-2)
+                    & (xy_VertexCR[0] != self.x_substations),
+                    np.isclose(xy_VertexCR[1], self.y_substations, atol=1e-2)
+                    & (xy_VertexCR[1] != self.y_substations),
+                )
+            )
+            with subtests.test(f"substation {idx_T} exact xor perturbed"):
+                assert matches_exactly ^ matches_with_perturbation  # boolean xor
+
+    def test_nowarning(self, subtests):
+        """
+        Test that no warnings are raised when turbines are positioned without overlap.
+
+        This test verifies that the OptiwindnetCollection component runs without
+        warnings when turbine positions are adjusted to avoid overlap. It repositions
+        turbines along a linear interpolation between the first and last turbine
+        positions, then runs the model with warnings set to raise errors. The test
+        also validates that the total cable length calculation produces the expected
+        reference value.
+        """
+
+        # deep copy modeling options and adjust
+        modeling_options = self.modeling_options
+
+        # create the OpenMDAO model
+        model = om.Group()
+        collection_mini = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=modeling_options,
+            ),
+        )
+
+        # move the turbines so they don't overlap anymore
+        self.x_turbines[1] = 0.3 * self.x_turbines[0] + 0.7 * self.x_turbines[-1]
+        self.y_turbines[1] = 0.3 * self.y_turbines[0] + 0.7 * self.y_turbines[-1]
+        self.x_turbines[2] = 0.7 * self.x_turbines[0] + 0.3 * self.x_turbines[-1]
+        self.y_turbines[2] = 0.7 * self.y_turbines[0] + 0.3 * self.y_turbines[-1]
+
+        prob = om.Problem(model)
+        prob.setup()
+
+        prob.set_val("collection.x_turbines", self.x_turbines)
+        prob.set_val("collection.y_turbines", self.y_turbines)
+        prob.set_val("collection.x_substations", self.x_substations)
+        prob.set_val("collection.y_substations", self.y_substations)
+
+        # make sure no warnings occur when the turbines don't overlap
+        with subtests.test("no warning for unique turbines/substations"):
+            with warnings.catch_warnings():
+                warnings.simplefilter("error")
+                # run optiwindnet
+                prob.run_model()
+
+        # make sure that it still runs and we match a reference value
+        total_length_cables_reference = 2612.01404984
+        with subtests.test("match reference value"):
+            assert np.isclose(
+                prob.get_val("collection.total_length_cables"),
+                total_length_cables_reference,
+            )
+
+
+class TestOptiWindNetCollectionSubstationOverlap:
+
+    def setup_method(self):
+        self.n_turbines = 4
+        self.x_turbines = 7.0 * 130.0 * np.array([-1.0, 0.0, 1.0, 2.0])
+        self.y_turbines = 7.0 * 130.0 * np.array([-1.0, 0.0, 1.0, 2.0])
+        self.x_substations = np.array([0.0])
+        self.y_substations = np.array([0.0])
+        self.modeling_options = make_modeling_options(
+            self.x_turbines,
+            self.y_turbines,
+            self.x_substations,
+            self.y_substations,
+        )
+
+        # create the OpenMDAO model
+        model = om.Group()
+        self.collection = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=self.modeling_options,
+            ),
+        )
+
+        self.prob = om.Problem(model)
+        self.prob.setup()
+
+    def test_perturbation_and_warning(self, subtests):
+        """
+        Test that OptiwindnetCollection issues a warning when turbines and/or substations
+        have coincident coordinates, but still produces valid results.
+
+        This test verifies that:
+        1. A warning is raised matching the pattern about coincident turbines/substations
+        2. The model still executes successfully despite the warning
+        3. The calculated total cable length matches the expected reference value
+        """
+
+        # deep copy modeling options and adjust
+        modeling_options = self.modeling_options
+
+        # create the OpenMDAO model
+        model = om.Group()
+        collection_mini = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=modeling_options,
+            ),
+        )
+
+        prob = om.Problem(model)
+        prob.setup()
+
+        prob.set_val("collection.x_turbines", self.x_turbines)
+        prob.set_val("collection.y_turbines", self.y_turbines)
+        prob.set_val("collection.x_substations", self.x_substations)
+        prob.set_val("collection.y_substations", self.y_substations)
+
+        with subtests.test("warn on turbine/substation intersection"):
+            with pytest.warns(
+                match=r"coincident turbines and/or substations in optiwindnet setup"
+            ) as warning:
+                # run optiwindnet
+                prob.run_model()
+                for w in warning:
+                    print(w.message)
+
+        # make sure that it still runs and we match a reference value
+        total_length_cables_reference = 3860.80302628
+        with subtests.test("match reference value"):
+            assert np.isclose(
+                prob.get_val("collection.total_length_cables"),
+                total_length_cables_reference,
+            )
+
+        # make sure the values in the optiwindnet graph are each close to a
+        # turbine but also include perturbation where it should be
+        T = collection_mini.graph.graph["T"]
+        R = collection_mini.graph.graph["R"]
+        VertexC = np.array(collection_mini.graph.graph["VertexC"])
+
+        for idx_T, xy_VertexCT in enumerate(VertexC[:T]):
+            # check if this turbine coordinate matches a turbine position (exactly or with perturbation)
+            matches_exactly = np.any(
+                np.logical_and(
+                    xy_VertexCT[0] == self.x_turbines,
+                    xy_VertexCT[1] == self.y_turbines,
+                )
+            )
+            matches_with_perturbation = np.any(
+                np.logical_and(
+                    np.isclose(xy_VertexCT[0], self.x_turbines, atol=1e-2)
+                    & (xy_VertexCT[0] != self.x_turbines),
+                    np.isclose(xy_VertexCT[1], self.y_turbines, atol=1e-2)
+                    & (xy_VertexCT[1] != self.y_turbines),
+                )
+            )
+            with subtests.test(f"turbine {idx_T} exact xor perturbed"):
+                assert matches_exactly ^ matches_with_perturbation  # xor
+
+        for idx_R, xy_VertexCR in enumerate(VertexC[-R:]):
+            # check if this turbine coordinate matches a turbine position (exactly or with perturbation)
+            matches_exactly = np.any(
+                np.logical_and(
+                    xy_VertexCR[0] == self.x_substations,
+                    xy_VertexCR[1] == self.y_substations,
+                )
+            )
+            matches_with_perturbation = np.any(
+                np.logical_and(
+                    np.isclose(xy_VertexCR[0], self.x_substations, atol=1e-2)
+                    & (xy_VertexCR[0] != self.x_substations),
+                    np.isclose(xy_VertexCR[1], self.y_substations, atol=1e-2)
+                    & (xy_VertexCR[1] != self.y_substations),
+                )
+            )
+            with subtests.test(f"substation {idx_T} exact xor perturbed"):
+                assert matches_exactly ^ matches_with_perturbation  # xor
+
+    def test_nowarning(self, subtests):
+        """
+        Test that no warnings are raised when turbines are positioned without overlap.
+
+        This test verifies that the OptiwindnetCollection component runs without
+        warnings when turbine positions are adjusted to avoid overlap. It repositions
+        turbines along a linear interpolation between the first and last turbine
+        positions, then runs the model with warnings set to raise errors. The test
+        also validates that the total cable length calculation produces the expected
+        reference value.
+        """
+
+        # deep copy modeling options and adjust
+        modeling_options = self.modeling_options
+
+        # create the OpenMDAO model
+        model = om.Group()
+        collection_mini = model.add_subsystem(
+            "collection",
+            ard_own.OptiwindnetCollection(
+                modeling_options=modeling_options,
+            ),
+        )
+
+        # move the substations so they don't overlap anymore
+        self.x_substations[0] = 100.0
+        self.y_substations[0] = 100.0
+
+        prob = om.Problem(model)
+        prob.setup()
+
+        prob.set_val("collection.x_turbines", self.x_turbines)
+        prob.set_val("collection.y_turbines", self.y_turbines)
+        prob.set_val("collection.x_substations", self.x_substations)
+        prob.set_val("collection.y_substations", self.y_substations)
+
+        # make sure no warnings occur when the turbines don't overlap
+        with subtests.test("no warning for unique turbines/substations"):
+            with warnings.catch_warnings():
+                warnings.simplefilter("error")
+                # run optiwindnet
+                prob.run_model()
+
+        # make sure that it still runs and we match a reference value
+        total_length_cables_reference = 3860.80302528
+        with subtests.test("match reference value"):
+            assert np.isclose(
+                prob.get_val("collection.total_length_cables"),
+                total_length_cables_reference,
+            )

From aecfed651dd02445b3b14e49919499ae3783cdf4 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 6 Jan 2026 09:46:19 -0700
Subject: [PATCH 07/30] WISDEM NSGA2 incorporation (#158)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* added NSGA2 to optimizer options

* removed zero velocity rows from floris results

* add example 06

* udpate

* adjust pyproject to use dev branch

* added gfortran for running on GH action runner

* undo dev branching

* black reformat plus added copilot-requested changes for viz utils

* added forgotten file

* add unit testing for nsga2 implementation

* address @jaredthomas68 comments

* add ard yaml

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 ard/api/interface.py                          |  51 +-
 ard/viz/utils.py                              |  27 ++
 .../inputs/ard_system.yaml                    |  91 ++++
 .../inputs/windio.yaml                        |  34 ++
 .../optimization_demo.ipynb                   | 434 ++++++++++++++++++
 .../api/inputs_onshore/ard_system_NSGA2.yaml  |  98 ++++
 test/unit/ard/api/test_multiobjective.py      |  78 ++++
 test/unit/ard/viz/test_utils.py               |  36 ++
 8 files changed, 827 insertions(+), 22 deletions(-)
 create mode 100644 ard/viz/utils.py
 create mode 100644 examples/06_onshore_multiobjective/inputs/ard_system.yaml
 create mode 100644 examples/06_onshore_multiobjective/inputs/windio.yaml
 create mode 100644 examples/06_onshore_multiobjective/optimization_demo.ipynb
 create mode 100644 test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
 create mode 100644 test/unit/ard/viz/test_utils.py

diff --git a/ard/api/interface.py b/ard/api/interface.py
index 40a795db..73ec9032 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -1,6 +1,7 @@
 import importlib
 import openmdao.api as om
 from openmdao.drivers.doe_driver import DOEGenerator
+from wisdem.optimization_drivers.nsga2_driver import NSGA2Driver
 from openmdao.utils.file_utils import clean_outputs
 from ard.utils.io import load_yaml, replace_key_value
 from ard.utils.logging import prepend_tabs_to_stdio
@@ -229,29 +230,35 @@ def set_up_system_recursive(
         if analysis_options:
             # set up driver
             if "driver" in analysis_options:
-                Driver = getattr(om, analysis_options["driver"]["name"])
-
-                # handle DOE drivers with special treatment
-                if Driver == om.DOEDriver:
-                    generator = None
-                    if "generator" in analysis_options["driver"]:
-                        if type(analysis_options["driver"]["generator"]) == dict:
-                            gen_dict = analysis_options["driver"]["generator"]
-                            generator = getattr(om, gen_dict["name"])(
-                                **gen_dict["args"]
-                            )
-                        elif isinstance(
-                            analysis_options["driver"]["generator"], DOEGenerator
-                        ):
-                            generator = analysis_options["driver"]["generator"]
-                        else:
-                            raise NotImplementedError(
-                                "Only dictionary-specified or OpenMDAO "
-                                "DOEGenerator generators have been implemented."
-                            )
-                    prob.driver = Driver(generator)
+
+                name_driver = analysis_options["driver"]["name"]
+
+                if name_driver == "NSGA2":
+                    prob.driver = NSGA2Driver()
                 else:
-                    prob.driver = Driver()
+                    Driver = getattr(om, name_driver)
+
+                    # handle DOE drivers with special treatment
+                    if Driver == om.DOEDriver:
+                        generator = None
+                        if "generator" in analysis_options["driver"]:
+                            if type(analysis_options["driver"]["generator"]) == dict:
+                                gen_dict = analysis_options["driver"]["generator"]
+                                generator = getattr(om, gen_dict["name"])(
+                                    **gen_dict["args"]
+                                )
+                            elif isinstance(
+                                analysis_options["driver"]["generator"], DOEGenerator
+                            ):
+                                generator = analysis_options["driver"]["generator"]
+                            else:
+                                raise NotImplementedError(
+                                    "Only dictionary-specified or OpenMDAO "
+                                    "DOEGenerator generators have been implemented."
+                                )
+                        prob.driver = Driver(generator)
+                    else:
+                        prob.driver = Driver()
 
                 # handle the options now
                 if "options" in analysis_options["driver"]:
diff --git a/ard/viz/utils.py b/ard/viz/utils.py
new file mode 100644
index 00000000..30a4581a
--- /dev/null
+++ b/ard/viz/utils.py
@@ -0,0 +1,27 @@
+import numpy as np
+
+
+def get_plot_range(values, pct_buffer=5.0):
+    """
+    get the min and max values for a plot axis with a buffer applied
+
+    Parameters
+    ----------
+    values : np.array
+        the array of values in a given dimension
+    pct_buffer : float, optional
+        percent that should be included as a buffer, by default 5.0
+
+    Returns
+    -------
+    float
+        minimum value for the plot range
+    float
+        maximum value for the plot range
+    """
+    min_value = np.min(values)
+    max_value = np.max(values)
+    dvalues = max_value - min_value
+    min_value = min_value - pct_buffer / 100.0 * dvalues
+    max_value = max_value + pct_buffer / 100.0 * dvalues
+    return min_value, max_value
diff --git a/examples/06_onshore_multiobjective/inputs/ard_system.yaml b/examples/06_onshore_multiobjective/inputs/ard_system.yaml
new file mode 100644
index 00000000..d0e54031
--- /dev/null
+++ b/examples/06_onshore_multiobjective/inputs/ard_system.yaml
@@ -0,0 +1,91 @@
+modeling_options:
+  windIO_plant: !include windio.yaml
+  layout:
+    type: gridfarm
+    N_turbines: 25
+    N_substations: 1
+    spacing_primary: 7.0
+    spacing_secondary: 7.0
+    angle_orientation: 0.0
+    angle_skew: 0.0
+  aero:
+    return_turbine_output: True
+  floris:
+    peak_shaving_fraction: 0.2
+    peak_shaving_TI_threshold: 0.0
+  collection:
+    max_turbines_per_string: 8
+    solver_name: highs
+    solver_options:
+      time_limit: 60
+      mip_gap: 0.02
+    model_options:
+      topology: radial  # radial, branched
+      feeder_route: segmented
+      feeder_limit: unlimited
+  offshore: false
+  floating: false
+  costs:
+    rated_power: 3400000.0  # W
+    num_blades: 3
+    rated_thrust_N: 645645.83964671
+    gust_velocity_m_per_s: 52.5
+    blade_surface_area: 69.7974979
+    tower_mass: 620.4407337521
+    nacelle_mass: 101.98582836439
+    hub_mass: 8.38407517646
+    blade_mass: 14.56341339641
+    foundation_height: 0.0
+    commissioning_cost_kW: 44.0
+    decommissioning_cost_kW: 58.0
+    trench_len_to_substation_km: 50.0
+    distance_to_interconnect_mi: 4.97096954
+    interconnect_voltage_kV: 130.0
+    tcc_per_kW: 1300.00  # (USD/kW)
+    opex_per_kW: 44.00  # (USD/kWh)
+
+system: onshore
+
+analysis_options:
+  driver:
+    name: NSGA2
+    options:
+      max_gen: 10
+      pop_size: 10
+      run_parallel: False
+  design_variables:
+    spacing_primary:
+      lower:  3.0
+      upper: 12.0
+      scaler: 0.14
+    spacing_secondary:
+      lower:  3.0
+      upper: 12.0
+      scaler: 0.14
+    angle_orientation:
+      lower: -180.0
+      upper:  180.0
+      scaler: 0.025
+    angle_skew:
+      lower: -45.0
+      upper:  45.0
+      scaler: 0.11
+  constraints:
+    boundary_distances:
+      units: km
+      upper: 0.0
+      scaler: 2.0
+    spacing_constraint.turbine_spacing:
+      units: km
+      lower: 0.552
+  objectives:
+    financese.lcoe:
+      scaler: 10.0
+    # AEP_farm:
+    #   scaler: -0.01
+    #   units: GW*h
+    area_tight:
+      units: km**2
+      scaler: 0.1
+  recorder:
+    filepath: cases.sql
diff --git a/examples/06_onshore_multiobjective/inputs/windio.yaml b/examples/06_onshore_multiobjective/inputs/windio.yaml
new file mode 100644
index 00000000..b69c8274
--- /dev/null
+++ b/examples/06_onshore_multiobjective/inputs/windio.yaml
@@ -0,0 +1,34 @@
+name: Ard Example 01 onshore wind plant
+site:
+    name: Ard Example 01 offshore wind site
+    boundaries:
+        polygons:
+            - x: [ 1500.0,  3000.0,  3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0]
+              y: [ 3000.0,  1500.0, -1500.0, -3000.0, -3000.0, -1500.0,  1500.0,  3000.0]
+    energy_resource:
+        name: Ard Example 01 offshore energy resource
+        wind_resource: !include ../../data/windIO-plant_wind-resource_wrg-example.yaml
+wind_farm:
+    name: Ard Example 01 offshore wind farm
+    layouts:
+        coordinates:
+            x: [
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0,
+                -2500.0, -1250.0,     0.0,  1250.0,  2500.0
+            ]
+            y: [
+                -2500.0, -2500.0, -2500.0, -2500.0, -2500.0,
+                -1250.0, -1250.0, -1250.0, -1250.0, -1250.0,
+                    0.0,     0.0,     0.0,     0.0,     0.0,
+                 1250.0,  1250.0,  1250.0,  1250.0,  1250.0,
+                 2500.0,  2500.0,  2500.0,  2500.0,  2500.0
+            ]
+    turbine: !include ../../data/windIO-plant_turbine_IEA-3.4MW-130m-RWT.yaml
+    electrical_substations:
+        - electrical_substation:
+            coordinates:
+                x: [100.0]
+                y: [100.0]
\ No newline at end of file
diff --git a/examples/06_onshore_multiobjective/optimization_demo.ipynb b/examples/06_onshore_multiobjective/optimization_demo.ipynb
new file mode 100644
index 00000000..85ef49dc
--- /dev/null
+++ b/examples/06_onshore_multiobjective/optimization_demo.ipynb
@@ -0,0 +1,434 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0a8540f7",
+   "metadata": {},
+   "source": [
+    "# 06: Onshore multi-objective\n",
+    "\n",
+    "In this example, we will demonstrate `Ard`'s ability to run a multi-objective analysis and optimization.\n",
+    "\n",
+    "We can start by loading what we need to run the problem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d75b4457",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path  # optional, for nice path specifications\n",
+    "\n",
+    "import pprint as pp  # optional, for nice printing\n",
+    "import numpy as np  # numerics library\n",
+    "import matplotlib.pyplot as plt  # plotting capabilities\n",
+    "\n",
+    "import ard  # technically we only really need this\n",
+    "from ard.utils.io import load_yaml  # we grab a yaml loader here\n",
+    "from ard.api import set_up_ard_model  # the secret sauce\n",
+    "from ard.viz.layout import plot_layout  # a plotting tool!\n",
+    "from ard.viz.utils import get_plot_range  # buffered range tool\n",
+    "\n",
+    "import openmdao.api as om  # for N2 diagrams from the OpenMDAO backend\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf2ceef4",
+   "metadata": {},
+   "source": [
+    "This will do for now.\n",
+    "We can probably make it a bit cleaner for a later release.\n",
+    "\n",
+    "Now, we can set up a case.\n",
+    "We do it a little verbosely so that our documentation system can grab it, you can generally just use relative paths.\n",
+    "We grab the file at `inputs/ard_system.yaml`, which describes the `Ard` system for this problem.\n",
+    "It references, in turn, the `inputs/windio.yaml` file, which is where we define the plant we want to optimize, and an initial setup for it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "29850609",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running OpenMDAO util to clean the output directories...\n",
+      "\tFound 1 OpenMDAO output directories:\n",
+      "\tRemoved case_files/ard_problem_out\n",
+      "\tRemoved 1 OpenMDAO output directories.\n",
+      "... done.\n",
+      "\n",
+      "Created top-level OpenMDAO problem: top_level.\n",
+      "Adding top_level.\n",
+      "\tAdding layout2aep.\n",
+      "\t\tAdding layout to layout2aep.\n",
+      "\t\tAdding aepFLORIS to layout2aep.\n",
+      "\tActivating approximate totals on layout2aep\n",
+      "\tAdding boundary.\n",
+      "\tAdding landuse.\n",
+      "\tAdding collection.\n",
+      "\tAdding spacing_constraint.\n",
+      "\tAdding tcc.\n",
+      "\tAdding landbosse.\n",
+      "\tAdding opex.\n",
+      "\tAdding financese.\n",
+      "System top_level built.\n",
+      "System top_level set up.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load input\n",
+    "path_inputs = Path.cwd().absolute() / \"inputs\"\n",
+    "input_dict = load_yaml(path_inputs / \"ard_system.yaml\")\n",
+    "\n",
+    "# create and setup system\n",
+    "prob = set_up_ard_model(input_dict=input_dict, root_data_path=path_inputs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0732705",
+   "metadata": {},
+   "source": [
+    "Above, you should see each of the groups or components described as they are added to the `Ard` model and, occasionally, some options being turned on on them, like semi-total finite differencing on groups.\n",
+    "\n",
+    "Next is some code you can flip on to use the [N2 diagram vizualization tools from the backend toolset, OpenMDAO, that we use](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_basics/n2_basics.html).\n",
+    "This can be a really handy debugging tool, if somewhat tricky to use; turned on it will show a comprehensive view of the system in terms of its components, variables, and connections, although we leave it off for now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "aa48878e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if False:\n",
+    "    # visualize model\n",
+    "    om.n2(prob)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "723f8210",
+   "metadata": {},
+   "source": [
+    "Now, we do a one-shot analysis.\n",
+    "The one-shot analysis will run a wind farm as specified in `inputs/windio.yaml` and with the models specified in `inputs/ard_system.yaml`, then dump the outputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b74f9d45",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "RESULTS:\n",
+      "\n",
+      "{'AEP_val': 406.5372933434125,\n",
+      " 'BOS_val': 41.68227106807093,\n",
+      " 'CapEx_val': 110.5,\n",
+      " 'LCOE_val': 37.274982094458494,\n",
+      " 'OpEx_val': 3.7400000000000007,\n",
+      " 'area_tight': 13.2496,\n",
+      " 'coll_length': 21.89865877023397,\n",
+      " 'turbine_spacing': 0.91}\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# run the model\n",
+    "prob.run_model()\n",
+    "\n",
+    "# collapse the test result data\n",
+    "test_data = {\n",
+    "    \"AEP_val\": float(prob.get_val(\"AEP_farm\", units=\"GW*h\")[0]),\n",
+    "    \"CapEx_val\": float(prob.get_val(\"tcc.tcc\", units=\"MUSD\")[0]),\n",
+    "    \"BOS_val\": float(prob.get_val(\"landbosse.total_capex\", units=\"MUSD\")[0]),\n",
+    "    \"OpEx_val\": float(prob.get_val(\"opex.opex\", units=\"MUSD/yr\")[0]),\n",
+    "    \"LCOE_val\": float(prob.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0]),\n",
+    "    \"area_tight\": float(prob.get_val(\"landuse.area_tight\", units=\"km**2\")[0]),\n",
+    "    \"coll_length\": float(prob.get_val(\"collection.total_length_cables\", units=\"km\")[0]),\n",
+    "    \"turbine_spacing\": float(\n",
+    "        np.min(prob.get_val(\"spacing_constraint.turbine_spacing\", units=\"km\"))\n",
+    "    ),\n",
+    "}\n",
+    "\n",
+    "print(\"\\n\\nRESULTS:\\n\")\n",
+    "pp.pprint(test_data)\n",
+    "print(\"\\n\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3085438",
+   "metadata": {},
+   "source": [
+    "Now, we can optimize the same problem to understand the tradeoff between LCOE and land use area!\n",
+    "The optimization details are set under the `analysis_options` header in `inputs/ard_system.yaml`.\n",
+    "Here, we still use the four-dimensional rectilinear layout parameterization ($\\theta$) as design variables, constrain the farm such that the turbines are in the boundaries and satisfactorily spaced, and then we optimize for both LCOE and land use area.\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "\\textrm{minimize}_\\theta \\quad & \\begin{pmatrix}\n",
+    "    A_{\\mathrm{landuse}}(\\theta, \\ldots) \\\\\n",
+    "    \\mathrm{LCOE}(\\theta, \\ldots)\n",
+    "\\end{pmatrix} \\\\\n",
+    "\\textrm{subject to} \\quad & f_{\\mathrm{spacing}}(\\theta, \\ldots) < 0 \\\\\n",
+    "                          & f_{\\mathrm{boundary}}(\\theta, \\ldots) < 0\n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b0009663",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generation: 0 of 10\n",
+      "generation: 1 of 10\n",
+      "generation: 2 of 10\n",
+      "generation: 3 of 10\n",
+      "generation: 4 of 10\n",
+      "generation: 5 of 10\n",
+      "generation: 6 of 10\n",
+      "generation: 7 of 10\n",
+      "generation: 8 of 10\n",
+      "generation: 9 of 10\n",
+      "generation: 10 of 10\n",
+      "\n",
+      "\n",
+      "RESULTS (opt):\n",
+      "\n",
+      "{'AEP_val': 424.40487848403035,\n",
+      " 'BOS_val': 39.600972465841274,\n",
+      " 'CapEx_val': 110.5,\n",
+      " 'LCOE_val': 35.337890055621564,\n",
+      " 'OpEx_val': 3.7400000000000007,\n",
+      " 'area_tight': 4.701829411011188,\n",
+      " 'coll_length': 11.907005558904213,\n",
+      " 'turbine_spacing': 0.43220837800684214}\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "optimize = True  # set to False to skip optimization\n",
+    "if optimize:\n",
+    "    # run the optimization\n",
+    "    prob.run_driver()\n",
+    "\n",
+    "    # collapse the test result data\n",
+    "    test_data = {\n",
+    "        \"AEP_val\": float(prob.get_val(\"AEP_farm\", units=\"GW*h\")[0]),\n",
+    "        \"CapEx_val\": float(prob.get_val(\"tcc.tcc\", units=\"MUSD\")[0]),\n",
+    "        \"BOS_val\": float(prob.get_val(\"landbosse.total_capex\", units=\"MUSD\")[0]),\n",
+    "        \"OpEx_val\": float(prob.get_val(\"opex.opex\", units=\"MUSD/yr\")[0]),\n",
+    "        \"LCOE_val\": float(prob.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0]),\n",
+    "        \"area_tight\": float(prob.get_val(\"landuse.area_tight\", units=\"km**2\")[0]),\n",
+    "        \"coll_length\": float(\n",
+    "            prob.get_val(\"collection.total_length_cables\", units=\"km\")[0]\n",
+    "        ),\n",
+    "        \"turbine_spacing\": float(\n",
+    "            np.min(prob.get_val(\"spacing_constraint.turbine_spacing\", units=\"km\"))\n",
+    "        ),\n",
+    "    }\n",
+    "\n",
+    "    # clean up the recorder\n",
+    "    prob.cleanup()\n",
+    "\n",
+    "    # print the results\n",
+    "    print(\"\\n\\nRESULTS (opt):\\n\")\n",
+    "    pp.pprint(test_data)\n",
+    "    print(\"\\n\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5fb8cca",
+   "metadata": {},
+   "source": [
+    "The result is no longer a single farm... we need to extract the multi-objective data now."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "49f0bc84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract the multi-objective data from the driver\n",
+    "obj_nd = prob.driver.obj_nd.copy()\n",
+    "obj_nd = obj_nd[obj_nd[:, 0].argsort()]  # Sort rows by the first column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "22d330a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Access the recorder data\n",
+    "case_reader = om.CaseReader(prob.get_outputs_dir() / \"cases.sql\")\n",
+    "\n",
+    "# Get all driver cases\n",
+    "driver_cases = case_reader.list_cases(\"driver\", out_stream=None)\n",
+    "\n",
+    "# Extract data from all cases\n",
+    "results = []\n",
+    "for case_id in driver_cases:\n",
+    "\n",
+    "    case = case_reader.get_case(case_id)\n",
+    "\n",
+    "    # Extract specific variables you're interested in\n",
+    "    result = {\n",
+    "        \"case_id\": case_id,\n",
+    "        \"LCOE\": case.get_val(\"financese.lcoe\", units=\"USD/MW/h\")[0],\n",
+    "        \"area_tight\": case.get_val(\"area_tight\", units=\"km*km\")[0],\n",
+    "    }\n",
+    "    results.append(result)\n",
+    "\n",
+    "# Convert to arrays for plotting/analysis\n",
+    "case_id_history = np.array([int(r[\"case_id\"].split(\"|\")[-1]) for r in results])\n",
+    "lcoe_history = np.array([r[\"LCOE\"] for r in results])\n",
+    "area_tight_history = np.array([r[\"area_tight\"] for r in results])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "20c15747",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot all of the points in the optimization histories\n",
+    "fig, ax = plt.subplots()\n",
+    "ct0 = ax.scatter(area_tight_history, lcoe_history, c=case_id_history / max(case_id_history))\n",
+    "cb0 = fig.colorbar(ct0)\n",
+    "ax.set_xlabel(\"land use area, $A_{\\\\mathrm{landuse}}$ (km)\")\n",
+    "ax.set_ylabel(\"levelized cost of energy, $\\\\mathrm{LCOE}$ (\\\\$/MWh)\")\n",
+    "cb0.set_label(\"optimization progress\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26d7da02",
+   "metadata": {},
+   "source": [
+    "These results can be hit or miss when there are not enough points sampled.\n",
+    "We use a population size of ten per generation over ten generations for the example, which is _not_ a lot.\n",
+    "But we should see that as the optimization progresses, the points should tend toward lower LCOE and lower land use.\n",
+    "You can change `pop_size` and `max_gen` in `inputs/ard_system:analysis_options` to improve the resolution of the Pareto fronts.\n",
+    "\n",
+    "We can also post-process the results to extract the Pareto front."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5b6cd3eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Combine AEP and LCOE into a single array for easier processing\n",
+    "data = np.column_stack((area_tight_history, lcoe_history))\n",
+    "\n",
+    "# Sort by AEP (descending) and then by LCOE (ascending)\n",
+    "data = data[np.lexsort((lcoe_history, area_tight_history))]\n",
+    "\n",
+    "# Compute the Pareto front\n",
+    "pareto_front = [data[0]]\n",
+    "for point in data[1:]:\n",
+    "    if point[1] < pareto_front[-1][1]:  # Check if LCOE is lower\n",
+    "        pareto_front.append(point)\n",
+    "\n",
+    "pareto_front = np.array(pareto_front)\n",
+    "\n",
+    "# Extract AEP and LCOE values for the Pareto front\n",
+    "pareto0 = pareto_front[:, 0]\n",
+    "pareto1 = pareto_front[:, 1]\n",
+    "\n",
+    "# Plot the Pareto front\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.scatter(area_tight_history, lcoe_history, label=\"All Points\", alpha=0.5)\n",
+    "plt.plot(pareto0, pareto1, \"-o\", color=\"red\", label=\"Pareto Front\", linewidth=2)\n",
+    "plt.xlabel(\"AEP (GW*h)\")\n",
+    "plt.ylabel(\"LCOE (USD/MW/h)\")\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.xlim(*get_plot_range(pareto0))\n",
+    "plt.ylim(*get_plot_range(pareto1))\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ard-dev-env",
+   "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.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml b/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
new file mode 100644
index 00000000..ef439ede
--- /dev/null
+++ b/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
@@ -0,0 +1,98 @@
+modeling_options: &modeling_options
+  case_name: test_multiobjective
+  windIO_plant: !include windio.yaml
+  layout:
+      type: gridfarm
+      N_turbines: 25
+      N_substations: 1
+      spacing_primary: 7.0
+      spacing_secondary: 7.0
+      angle_orientation: 0.0
+      angle_skew: 0.0
+  aero:
+    return_turbine_output: True
+  floris:
+    peak_shaving_fraction: 0.2
+    peak_shaving_TI_threshold: 0.0
+
+system:
+  type: group
+  systems:
+    layout:
+      type: component
+      module: ard.layout.gridfarm
+      object: GridFarmLayout
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+    aepFLORIS:
+      type: component
+      module: ard.farm_aero.floris
+      object: FLORISAEP
+      promotes: ["AEP_farm"]
+      kwargs:
+        modeling_options: *modeling_options
+        data_path:
+        case_title: "default"
+    lug:
+      type: group
+      systems:
+        landuse:
+          type: component
+          module: ard.layout.gridfarm
+          object: GridFarmLanduse
+          promotes: ["*"]
+          kwargs:
+            modeling_options: *modeling_options
+      promotes: ["*"]
+    boundary:
+      type: component
+      module: ard.layout.boundary
+      object: FarmBoundaryDistancePolygon
+      promotes: ["*"]
+      kwargs:
+        modeling_options: *modeling_options
+  connections:
+    - ["x_turbines", "aepFLORIS.x_turbines"]
+    - ["x_turbines", "aepFLORIS.y_turbines"]
+
+analysis_options:
+  driver:
+    name: NSGA2
+    options:
+      max_gen: 3
+      pop_size: 2
+      Pc: 0.9
+      eta_c: 20.0
+      Pm: 0.1
+      eta_m: 20.0
+      run_parallel: False
+  design_variables:
+    spacing_primary:
+      lower:  3.0
+      upper: 20.0
+    spacing_secondary:
+      lower:  3.0
+      upper: 20.0
+    angle_orientation:
+      lower: -180.0
+      upper:  180.0
+    angle_skew:
+      lower: -45.0
+      upper:  45.0
+  constraints:
+    boundary_distances:
+      units: km
+      upper: 0.0
+      scaler: 2.0
+  objectives:
+    AEP_farm:
+      scaler: 1.0
+      units: GW*h
+    lug.landuse.area_tight:
+      scaler: 1.0
+      units: km**2
+      index: 0
+
+  recorder:
+    filepath: cases.sql
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/unit/ard/api/test_multiobjective.py
index 7260acb3..38097ae0 100644
--- a/test/unit/ard/api/test_multiobjective.py
+++ b/test/unit/ard/api/test_multiobjective.py
@@ -1,5 +1,9 @@
 from pathlib import Path
 
+import numpy as np
+
+from wisdem.optimization_drivers.nsga2_driver import NSGA2Driver
+
 from ard.utils.io import load_yaml
 from ard.api import set_up_ard_model
 
@@ -86,3 +90,77 @@ def test_raise_scipy_MOO_error(self):
 
             # attempt to run the driver
             self.da_plough.run_driver()
+
+
+class TestNSGA2:
+    def setup_method(self):
+
+        # create the simplest system that will compile
+        input_dict = self.input_dict = load_yaml(
+            Path(__file__).parent / "inputs_onshore" / "ard_system_NSGA2.yaml"
+        )
+
+        # create an ard model
+        self.da_plough = set_up_ard_model(
+            input_dict=input_dict,
+        )
+
+    def teardown_method(self):
+
+        # cleanup the ard model
+        self.da_plough.cleanup()
+        # necessary due to final_setup() call below?
+
+    def test_instantiation(self, subtests):
+
+        # make sure the driver is the right type
+        with subtests.test("driver type"):
+            assert type(self.da_plough.driver) == NSGA2Driver
+
+        # make sure the default parameters are in the driver
+        for opt_name, opt_val, comparison_fun in [
+            ("run_parallel", False, np.equal),
+            ("procs_per_model", 1, np.equal),
+            ("penalty_parameter", 0.0, np.isclose),
+            ("penalty_exponent", 1.0, np.isclose),
+            ("compute_pareto", True, np.equal),
+        ]:
+            with subtests.test(f"driver default {opt_name}"):
+                assert comparison_fun(self.da_plough.driver.options[opt_name], opt_val)
+
+        # make sure the parameters we set in the ard yaml are set
+        with subtests.test("driver setting max_gen"):
+            assert (
+                self.da_plough.driver.options["max_gen"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["max_gen"]
+            )
+        with subtests.test("driver setting pop_size"):
+            assert (
+                self.da_plough.driver.options["pop_size"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["pop_size"]
+            )
+        with subtests.test("driver setting Pc"):
+            assert (
+                self.da_plough.driver.options["Pc"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["Pc"]
+            )
+        with subtests.test("driver setting eta_c"):
+            assert (
+                self.da_plough.driver.options["eta_c"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["eta_c"]
+            )
+        with subtests.test("driver setting Pm"):
+            assert (
+                self.da_plough.driver.options["Pm"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["Pm"]
+            )
+        with subtests.test("driver setting eta_m"):
+            assert (
+                self.da_plough.driver.options["eta_m"]
+                == self.input_dict["analysis_options"]["driver"]["options"]["eta_m"]
+            )
+
+    def test_driver_run(self):
+
+        # make sure the driver runs to completion
+        self.da_plough.run_driver()
diff --git a/test/unit/ard/viz/test_utils.py b/test/unit/ard/viz/test_utils.py
new file mode 100644
index 00000000..02bd37c3
--- /dev/null
+++ b/test/unit/ard/viz/test_utils.py
@@ -0,0 +1,36 @@
+import numpy as np
+
+import ard.viz.utils as viz_utils
+
+
+def test_get_plot_range(subtests):
+    """
+    test the get_plot_range function by feeding it multiple arguments for
+    matches against gold standard values
+    """
+
+    values_args_truths = [
+        (
+            np.array([4.0, 5.0, 6.0]),
+            None,
+            (4.0 - (6.0 - 4.0) * 0.05, 6.0 + (6.0 - 4.0) * 0.05),
+        ),
+        (
+            np.linspace(-3.0, 10.0, 25),
+            None,
+            (-3.0 - (10.0 - -3.0) * 0.05, 10.0 + (10.0 - -3.0) * 0.05),
+        ),
+        (
+            np.linspace(-3.0, 10.0, 25),
+            7.5,
+            (-3.0 - (10.0 - -3.0) * 0.075, 10.0 + (10.0 - -3.0) * 0.075),
+        ),
+    ]
+
+    for idx, (value, arg, truth) in enumerate(values_args_truths):
+        with subtests.test(f"value {idx:02d}"):
+            if arg is None:
+                rv = viz_utils.get_plot_range(value)
+            else:
+                rv = viz_utils.get_plot_range(value, arg)
+            assert np.allclose(rv, truth)

From 79cb5ee8e5c833a66820e640be5802a7a61503b4 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 6 Jan 2026 13:59:47 -0700
Subject: [PATCH 08/30] Feature/goodybag (#165)

* readme adjustments to address and close #154 and numpy version
adjustment to close #157

* refactor the test organization for better incorporation of subpackages

* black reformat

* update github runner

* address jared suggestions
---
 .../workflows/python-tests-consolidated.yaml  |   6 ++--
 README.md                                     |  33 ++++++++++++------
 .../optimization_demo.ipynb                   |   4 ++-
 pyproject.toml                                |   2 +-
 .../GulfOfMaine_bathymetry_100x99.txt         |   0
 ...er_thrust_table_ccblade_IEA-22-284-RWT.csv |   0
 ...r_thrust_table_ccblade_IEA-3p4-130-RWT.csv |   0
 test/{ => ard}/data/wrg_example.wrg           |   0
 .../inputs_offshore_floating/ard_system.yaml  |   0
 .../inputs_offshore_monopile/ard_system.yaml  |   0
 .../api/inputs_onshore/ard_system.yaml        |   0
 .../system}/api/test_LCOE_LB_stack.py         |   2 +-
 .../system}/api/test_LCOE_LB_stack_pyrite.npz | Bin
 .../system}/api/test_LCOE_OFB_stack.py        |   2 +-
 .../api/test_LCOE_OFB_stack_pyrite.npz        | Bin
 .../system}/api/test_LCOE_OFL_stack.py        |   2 +-
 .../api/test_LCOE_OFL_stack_pyrite.npz        | Bin
 .../ard => ard/system}/api/test_interface.py  |   0
 .../system}/collection/test_optiwindnet.py    |   0
 .../collection/test_optiwindnet_pyrite.npz    | Bin
 ...test_spacing_approximations_connections.py |   0
 .../test_boundary_distances_2p0D_pyrite.npz   | Bin
 .../test_boundary_distances_5p0D_pyrite.npz   | Bin
 .../test_boundary_distances_7p0D_pyrite.npz   | Bin
 .../system}/geometry/test_constraints.py      |   0
 .../system}/offshore/test_mooring_packing.py  |   0
 .../api/inputs_onshore/ard_system_NSGA2.yaml  |   0
 .../inputs_onshore/ard_system_bad_windio.yaml |   0
 .../ard_system_multiobjective.yaml            |   0
 .../unit}/api/inputs_onshore/windio.yaml      |   0
 .../unit}/api/test_interface_unit.py          |   4 +--
 .../unit}/api/test_multiobjective.py          |   0
 .../{unit => ard/unit/collection}/__init__.py |   0
 .../unit}/collection/test_optiwindnet.py      |   0
 .../collection/test_optiwindnet_pyrite.npz    | Bin
 .../unit}/collection/test_templates.py        |   0
 .../collection => ard/unit/cost}/__init__.py  |   0
 .../test_landbosse_wrap_baseline_farm.npz     | Bin
 .../ard => ard/unit}/cost/test_orbit_wrap.py  |   0
 .../cost/test_orbit_wrap_baseline_farm.npz    | Bin
 .../unit}/cost/test_spacing_approximations.py |   0
 .../ard => ard/unit}/cost/test_wisdem_wrap.py |   0
 .../cost => ard/unit/farm_aero}/__init__.py   |   0
 .../ard => ard/unit}/farm_aero/test_floris.py |   0
 .../farm_aero/test_floris_aep_pyrite.npz      | Bin
 .../farm_aero/test_floris_batch_pyrite.npz    | Bin
 .../unit}/farm_aero/test_templates.py         |   0
 .../unit}/geographic/test_geomorphology.py    |   0
 ...phology_depth_default_gradients_pyrite.npz | Bin
 ...est_geomorphology_depth_default_pyrite.npz | Bin
 test/{unit/ard => ard/unit}/layout/.gitignore |   0
 .../farm_aero => ard/unit/layout}/__init__.py |   0
 .../ard => ard/unit}/layout/test_boundary.py  |   0
 .../ard => ard/unit}/layout/test_fullfarm.py  |   0
 .../ard => ard/unit}/layout/test_gridfarm.py  |   0
 .../ard => ard/unit}/layout/test_spacing.py   |   0
 .../ard => ard/unit}/layout/test_sunflower.py |   0
 .../unit}/layout/test_sunflower_4D_pyrite.npz | Bin
 .../unit}/layout/test_sunflower_7D_pyrite.npz | Bin
 .../ard => ard/unit}/layout/test_templates.py |   0
 .../ard => ard/unit}/layout/test_viewshed.py  |   0
 .../unit}/offshore/test_mooringconstraint.py  |   0
 .../unit}/offshore/test_mooringdesign.py      |   0
 .../{unit/ard => ard/unit}/test_wind_query.py |   0
 .../ard => ard/unit}/utils/test_geometry.py   |   0
 test/{unit/ard => ard/unit}/utils/test_io.py  |   0
 .../ard => ard/unit}/utils/test_matematics.py |   0
 .../ard => ard/unit}/utils/test_utils.py      |   0
 .../ard/layout => ard/unit/viz}/__init__.py   |   0
 .../ard => ard/unit}/viz/test_plot_layout.py  |   0
 test/{unit/ard => ard/unit}/viz/test_utils.py |   0
 test/run_local_test_system.sh                 |   6 ++--
 test/run_local_test_unit.sh                   |   6 ++--
 test/unit/ard/viz/__init__.py                 |   0
 74 files changed, 40 insertions(+), 27 deletions(-)
 rename test/{ => ard}/data/offshore/GulfOfMaine_bathymetry_100x99.txt (100%)
 rename test/{ => ard}/data/power_thrust_table_ccblade_IEA-22-284-RWT.csv (100%)
 rename test/{ => ard}/data/power_thrust_table_ccblade_IEA-3p4-130-RWT.csv (100%)
 rename test/{ => ard}/data/wrg_example.wrg (100%)
 rename test/{system/ard => ard/system}/api/inputs_offshore_floating/ard_system.yaml (100%)
 rename test/{system/ard => ard/system}/api/inputs_offshore_monopile/ard_system.yaml (100%)
 rename test/{system/ard => ard/system}/api/inputs_onshore/ard_system.yaml (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_LB_stack.py (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_LB_stack_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_OFB_stack.py (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_OFB_stack_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_OFL_stack.py (100%)
 rename test/{system/ard => ard/system}/api/test_LCOE_OFL_stack_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/api/test_interface.py (100%)
 rename test/{system/ard => ard/system}/collection/test_optiwindnet.py (100%)
 rename test/{system/ard => ard/system}/collection/test_optiwindnet_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/cost/test_spacing_approximations_connections.py (100%)
 rename test/{system/ard => ard/system}/geometry/test_boundary_distances_2p0D_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/geometry/test_boundary_distances_5p0D_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/geometry/test_boundary_distances_7p0D_pyrite.npz (100%)
 rename test/{system/ard => ard/system}/geometry/test_constraints.py (100%)
 rename test/{system/ard => ard/system}/offshore/test_mooring_packing.py (100%)
 rename test/{unit/ard => ard/unit}/api/inputs_onshore/ard_system_NSGA2.yaml (100%)
 rename test/{unit/ard => ard/unit}/api/inputs_onshore/ard_system_bad_windio.yaml (100%)
 rename test/{unit/ard => ard/unit}/api/inputs_onshore/ard_system_multiobjective.yaml (100%)
 rename test/{unit/ard => ard/unit}/api/inputs_onshore/windio.yaml (100%)
 rename test/{unit/ard => ard/unit}/api/test_interface_unit.py (94%)
 rename test/{unit/ard => ard/unit}/api/test_multiobjective.py (100%)
 rename test/{unit => ard/unit/collection}/__init__.py (100%)
 rename test/{unit/ard => ard/unit}/collection/test_optiwindnet.py (100%)
 rename test/{unit/ard => ard/unit}/collection/test_optiwindnet_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/collection/test_templates.py (100%)
 rename test/{unit/ard/collection => ard/unit/cost}/__init__.py (100%)
 rename test/{unit/ard => ard/unit}/cost/test_landbosse_wrap_baseline_farm.npz (100%)
 rename test/{unit/ard => ard/unit}/cost/test_orbit_wrap.py (100%)
 rename test/{unit/ard => ard/unit}/cost/test_orbit_wrap_baseline_farm.npz (100%)
 rename test/{unit/ard => ard/unit}/cost/test_spacing_approximations.py (100%)
 rename test/{unit/ard => ard/unit}/cost/test_wisdem_wrap.py (100%)
 rename test/{unit/ard/cost => ard/unit/farm_aero}/__init__.py (100%)
 rename test/{unit/ard => ard/unit}/farm_aero/test_floris.py (100%)
 rename test/{unit/ard => ard/unit}/farm_aero/test_floris_aep_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/farm_aero/test_floris_batch_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/farm_aero/test_templates.py (100%)
 rename test/{unit/ard => ard/unit}/geographic/test_geomorphology.py (100%)
 rename test/{unit/ard => ard/unit}/geographic/test_geomorphology_depth_default_gradients_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/geographic/test_geomorphology_depth_default_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/layout/.gitignore (100%)
 rename test/{unit/ard/farm_aero => ard/unit/layout}/__init__.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_boundary.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_fullfarm.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_gridfarm.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_spacing.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_sunflower.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_sunflower_4D_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/layout/test_sunflower_7D_pyrite.npz (100%)
 rename test/{unit/ard => ard/unit}/layout/test_templates.py (100%)
 rename test/{unit/ard => ard/unit}/layout/test_viewshed.py (100%)
 rename test/{unit/ard => ard/unit}/offshore/test_mooringconstraint.py (100%)
 rename test/{unit/ard => ard/unit}/offshore/test_mooringdesign.py (100%)
 rename test/{unit/ard => ard/unit}/test_wind_query.py (100%)
 rename test/{unit/ard => ard/unit}/utils/test_geometry.py (100%)
 rename test/{unit/ard => ard/unit}/utils/test_io.py (100%)
 rename test/{unit/ard => ard/unit}/utils/test_matematics.py (100%)
 rename test/{unit/ard => ard/unit}/utils/test_utils.py (100%)
 rename test/{unit/ard/layout => ard/unit/viz}/__init__.py (100%)
 rename test/{unit/ard => ard/unit}/viz/test_plot_layout.py (100%)
 rename test/{unit/ard => ard/unit}/viz/test_utils.py (100%)
 delete mode 100644 test/unit/ard/viz/__init__.py

diff --git a/.github/workflows/python-tests-consolidated.yaml b/.github/workflows/python-tests-consolidated.yaml
index 90427099..fb420d8c 100644
--- a/.github/workflows/python-tests-consolidated.yaml
+++ b/.github/workflows/python-tests-consolidated.yaml
@@ -84,7 +84,7 @@ jobs:
         pip install .[dev]
     - name: Run unit tests with coverage
       run: |
-        pytest --cov=ard --cov-fail-under=80 test/unit
+        pytest --cov=ard --cov-fail-under=80 test/ard/unit
 
   test-system:
     name: Run system tests
@@ -124,8 +124,8 @@ jobs:
         pip install .[dev]
     - name: Run system tests with coverage
       run: |
-        pytest --cov=ard --cov-fail-under=50 test/system
-        # pytest --cov=ard --cov-fail-under=80 test/system
+        pytest --cov=ard --cov-fail-under=50 test/ard/system
+        # pytest --cov=ard --cov-fail-under=80 test/ard/system
 
   find-examples:
     name: Find all examples
diff --git a/README.md b/README.md
index efe2eec7..b3f7fe1a 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ Moreover, the design of any *one* of these aspects affects all the rest!
 In brief, we are designing `Ard` to be: principled, modular, extensible, and effective, to allow resource-specific wind farm layout optimization with realistic, well-posed constraints, holistic and complex objectives, and natural incorporation of multiple fidelities and disciplines.
 
 ## Documentation
+
 Ard documentation is available at [https://wisdem.github.io/Ard](https://wisdem.github.io/Ard)
 
 ## Installation instructions
@@ -31,6 +32,7 @@ Ard documentation is available at [https://wisdem.github.io/Ard](https://wisdem.
 `Ard` is currently in pre-release. It can be installed from PyPI or as a source-code installation.
 
 ### 1. Clone Ard source repository
+
 If installing from PyPI, skip to [step 2.](#2.-Set-up-environment). If installing from source, the source can be cloned from github using the following command in your preferred location:
 ```shell
 git clone git@github.com:WISDEM/Ard.git
@@ -41,49 +43,60 @@ cd Ard
 ```
 
 ### 2. Set up environment
-At this point, although not strictly required, we recommend creating a dedicated conda environment with `pip`, `python=3.12`, and `mamba` in it (except on apple silicon):
 
-#### On Apple silicon
-For Apple silicon, we recommend installing Ard natively.
+At this point, although not strictly required, we recommend creating a dedicated conda environment with `pip` and `python=3.12` in it:
+
 ```shell
-conda CONDA_SUBDIR=osx-arm64 conda create -n ard-env 
+conda create --name ard-env
 conda activate ard-env
-conda env config vars set CONDA_SUBDIR=osx-arm64 # this command makes the environment permanently native
-conda install python=3.12
+conda install python=3.12 pip -y
 ```
 
-#### Or, on Intel
+#### On Apple silicon
+
+For Apple silicon, the above will install for the default ("native") architecture.
+
+For some advanced users, installation specifying non-default architecture may be desirable for compatibility:
 ```shell
-create --name ard-env
+# ARCH_SPEC=osx-arm64  # native AMD on apple silicon, if Intel x64 is defaulted
+ARCH_SPEC=osx-64  # Intel x64 for Apple Binary Interface
+CONDA_SUBDIR=$ARCH_SPEC conda create --name ard-env
 conda activate ard-env
-conda install python=3.12 pip mamba -y
+conda env config vars set CONDA_SUBDIR=$ARCH_SPEC # this command makes the environment permanently native
+conda install python=3.12 pip -y
 ```
+The choice of `ARCH_SPEC` and corresponding configuration above can enable interfacing compatibly to software that has not been built for Apple silicon yet.
 
 ### 3. Install Ard
+
 From here, installation can be handled by `pip`.
 
 #### To install from PyPI
+
 ```shell
 pip install ard-nrel
 ```
 
 #### For a basic and static installation from source, run:
+
 ```shell
 pip install .
 ```
 
 #### For development (and really for everyone during pre-release), we recommend a full development installation from source:
+
 ```shell
 pip install -e .[dev,docs]
 ```
 which will install in "editable mode" (`-e`), such that changes made to the source will not require re-installation, and with additional optional packages for development and documentation (`[dev,docs]`).
 
 #### If you have problems with WISDEM not installing correctly
+
 There can be some hardware-software mis-specification issues with WISDEM installation from `pip` for MacOS 12 and 13 on machines with Apple Silicon.
 In the event of issues, WISDEM can be installed manually or using `conda` without issues, then `pip` installation can proceed.
 
 ```shell
-mamba install wisdem -y
+conda install wisdem -y
 pip install -e .[dev,docs]
 ```
 
diff --git a/examples/06_onshore_multiobjective/optimization_demo.ipynb b/examples/06_onshore_multiobjective/optimization_demo.ipynb
index 85ef49dc..1a55823b 100644
--- a/examples/06_onshore_multiobjective/optimization_demo.ipynb
+++ b/examples/06_onshore_multiobjective/optimization_demo.ipynb
@@ -340,7 +340,9 @@
    "source": [
     "# Plot all of the points in the optimization histories\n",
     "fig, ax = plt.subplots()\n",
-    "ct0 = ax.scatter(area_tight_history, lcoe_history, c=case_id_history / max(case_id_history))\n",
+    "ct0 = ax.scatter(\n",
+    "    area_tight_history, lcoe_history, c=case_id_history / max(case_id_history)\n",
+    ")\n",
     "cb0 = fig.colorbar(ct0)\n",
     "ax.set_xlabel(\"land use area, $A_{\\\\mathrm{landuse}}$ (km)\")\n",
     "ax.set_ylabel(\"levelized cost of energy, $\\\\mathrm{LCOE}$ (\\\\$/MWh)\")\n",
diff --git a/pyproject.toml b/pyproject.toml
index 8ceeacfc..33961d07 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -38,7 +38,7 @@ classifiers = [
   # "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-  "numpy<2.3",
+  "numpy",
   "floris>=4.3",
   "wisdem>=3.21",
   "NLopt",
diff --git a/test/data/offshore/GulfOfMaine_bathymetry_100x99.txt b/test/ard/data/offshore/GulfOfMaine_bathymetry_100x99.txt
similarity index 100%
rename from test/data/offshore/GulfOfMaine_bathymetry_100x99.txt
rename to test/ard/data/offshore/GulfOfMaine_bathymetry_100x99.txt
diff --git a/test/data/power_thrust_table_ccblade_IEA-22-284-RWT.csv b/test/ard/data/power_thrust_table_ccblade_IEA-22-284-RWT.csv
similarity index 100%
rename from test/data/power_thrust_table_ccblade_IEA-22-284-RWT.csv
rename to test/ard/data/power_thrust_table_ccblade_IEA-22-284-RWT.csv
diff --git a/test/data/power_thrust_table_ccblade_IEA-3p4-130-RWT.csv b/test/ard/data/power_thrust_table_ccblade_IEA-3p4-130-RWT.csv
similarity index 100%
rename from test/data/power_thrust_table_ccblade_IEA-3p4-130-RWT.csv
rename to test/ard/data/power_thrust_table_ccblade_IEA-3p4-130-RWT.csv
diff --git a/test/data/wrg_example.wrg b/test/ard/data/wrg_example.wrg
similarity index 100%
rename from test/data/wrg_example.wrg
rename to test/ard/data/wrg_example.wrg
diff --git a/test/system/ard/api/inputs_offshore_floating/ard_system.yaml b/test/ard/system/api/inputs_offshore_floating/ard_system.yaml
similarity index 100%
rename from test/system/ard/api/inputs_offshore_floating/ard_system.yaml
rename to test/ard/system/api/inputs_offshore_floating/ard_system.yaml
diff --git a/test/system/ard/api/inputs_offshore_monopile/ard_system.yaml b/test/ard/system/api/inputs_offshore_monopile/ard_system.yaml
similarity index 100%
rename from test/system/ard/api/inputs_offshore_monopile/ard_system.yaml
rename to test/ard/system/api/inputs_offshore_monopile/ard_system.yaml
diff --git a/test/system/ard/api/inputs_onshore/ard_system.yaml b/test/ard/system/api/inputs_onshore/ard_system.yaml
similarity index 100%
rename from test/system/ard/api/inputs_onshore/ard_system.yaml
rename to test/ard/system/api/inputs_onshore/ard_system.yaml
diff --git a/test/system/ard/api/test_LCOE_LB_stack.py b/test/ard/system/api/test_LCOE_LB_stack.py
similarity index 100%
rename from test/system/ard/api/test_LCOE_LB_stack.py
rename to test/ard/system/api/test_LCOE_LB_stack.py
index 4346bad5..88661eab 100644
--- a/test/system/ard/api/test_LCOE_LB_stack.py
+++ b/test/ard/system/api/test_LCOE_LB_stack.py
@@ -55,8 +55,8 @@ def test_model(self, subtests):
             test_data,
             Path(ard.__file__).parents[1]
             / "test"
-            / "system"
             / "ard"
+            / "system"
             / "api"
             / "test_LCOE_LB_stack_pyrite.npz",
             # rewrite=True,  # uncomment to write new pyrite file
diff --git a/test/system/ard/api/test_LCOE_LB_stack_pyrite.npz b/test/ard/system/api/test_LCOE_LB_stack_pyrite.npz
similarity index 100%
rename from test/system/ard/api/test_LCOE_LB_stack_pyrite.npz
rename to test/ard/system/api/test_LCOE_LB_stack_pyrite.npz
diff --git a/test/system/ard/api/test_LCOE_OFB_stack.py b/test/ard/system/api/test_LCOE_OFB_stack.py
similarity index 100%
rename from test/system/ard/api/test_LCOE_OFB_stack.py
rename to test/ard/system/api/test_LCOE_OFB_stack.py
index 91b12571..6f9f0c6b 100644
--- a/test/system/ard/api/test_LCOE_OFB_stack.py
+++ b/test/ard/system/api/test_LCOE_OFB_stack.py
@@ -64,8 +64,8 @@ def test_model(self, subtests):
             test_data,
             Path(ard.__file__).parents[1]
             / "test"
-            / "system"
             / "ard"
+            / "system"
             / "api"
             / "test_LCOE_OFB_stack_pyrite.npz",
             # rewrite=True,  # uncomment to write new pyrite file
diff --git a/test/system/ard/api/test_LCOE_OFB_stack_pyrite.npz b/test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz
similarity index 100%
rename from test/system/ard/api/test_LCOE_OFB_stack_pyrite.npz
rename to test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz
diff --git a/test/system/ard/api/test_LCOE_OFL_stack.py b/test/ard/system/api/test_LCOE_OFL_stack.py
similarity index 100%
rename from test/system/ard/api/test_LCOE_OFL_stack.py
rename to test/ard/system/api/test_LCOE_OFL_stack.py
index 8e1c5583..0e89187a 100644
--- a/test/system/ard/api/test_LCOE_OFL_stack.py
+++ b/test/ard/system/api/test_LCOE_OFL_stack.py
@@ -64,8 +64,8 @@ def test_model(self, subtests):
             test_data,
             Path(ard.__file__).parents[1]
             / "test"
-            / "system"
             / "ard"
+            / "system"
             / "api"
             / "test_LCOE_OFL_stack_pyrite.npz",
             # rewrite=True,  # uncomment to write new pyrite file
diff --git a/test/system/ard/api/test_LCOE_OFL_stack_pyrite.npz b/test/ard/system/api/test_LCOE_OFL_stack_pyrite.npz
similarity index 100%
rename from test/system/ard/api/test_LCOE_OFL_stack_pyrite.npz
rename to test/ard/system/api/test_LCOE_OFL_stack_pyrite.npz
diff --git a/test/system/ard/api/test_interface.py b/test/ard/system/api/test_interface.py
similarity index 100%
rename from test/system/ard/api/test_interface.py
rename to test/ard/system/api/test_interface.py
diff --git a/test/system/ard/collection/test_optiwindnet.py b/test/ard/system/collection/test_optiwindnet.py
similarity index 100%
rename from test/system/ard/collection/test_optiwindnet.py
rename to test/ard/system/collection/test_optiwindnet.py
diff --git a/test/system/ard/collection/test_optiwindnet_pyrite.npz b/test/ard/system/collection/test_optiwindnet_pyrite.npz
similarity index 100%
rename from test/system/ard/collection/test_optiwindnet_pyrite.npz
rename to test/ard/system/collection/test_optiwindnet_pyrite.npz
diff --git a/test/system/ard/cost/test_spacing_approximations_connections.py b/test/ard/system/cost/test_spacing_approximations_connections.py
similarity index 100%
rename from test/system/ard/cost/test_spacing_approximations_connections.py
rename to test/ard/system/cost/test_spacing_approximations_connections.py
diff --git a/test/system/ard/geometry/test_boundary_distances_2p0D_pyrite.npz b/test/ard/system/geometry/test_boundary_distances_2p0D_pyrite.npz
similarity index 100%
rename from test/system/ard/geometry/test_boundary_distances_2p0D_pyrite.npz
rename to test/ard/system/geometry/test_boundary_distances_2p0D_pyrite.npz
diff --git a/test/system/ard/geometry/test_boundary_distances_5p0D_pyrite.npz b/test/ard/system/geometry/test_boundary_distances_5p0D_pyrite.npz
similarity index 100%
rename from test/system/ard/geometry/test_boundary_distances_5p0D_pyrite.npz
rename to test/ard/system/geometry/test_boundary_distances_5p0D_pyrite.npz
diff --git a/test/system/ard/geometry/test_boundary_distances_7p0D_pyrite.npz b/test/ard/system/geometry/test_boundary_distances_7p0D_pyrite.npz
similarity index 100%
rename from test/system/ard/geometry/test_boundary_distances_7p0D_pyrite.npz
rename to test/ard/system/geometry/test_boundary_distances_7p0D_pyrite.npz
diff --git a/test/system/ard/geometry/test_constraints.py b/test/ard/system/geometry/test_constraints.py
similarity index 100%
rename from test/system/ard/geometry/test_constraints.py
rename to test/ard/system/geometry/test_constraints.py
diff --git a/test/system/ard/offshore/test_mooring_packing.py b/test/ard/system/offshore/test_mooring_packing.py
similarity index 100%
rename from test/system/ard/offshore/test_mooring_packing.py
rename to test/ard/system/offshore/test_mooring_packing.py
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml b/test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml
similarity index 100%
rename from test/unit/ard/api/inputs_onshore/ard_system_NSGA2.yaml
rename to test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml b/test/ard/unit/api/inputs_onshore/ard_system_bad_windio.yaml
similarity index 100%
rename from test/unit/ard/api/inputs_onshore/ard_system_bad_windio.yaml
rename to test/ard/unit/api/inputs_onshore/ard_system_bad_windio.yaml
diff --git a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml b/test/ard/unit/api/inputs_onshore/ard_system_multiobjective.yaml
similarity index 100%
rename from test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
rename to test/ard/unit/api/inputs_onshore/ard_system_multiobjective.yaml
diff --git a/test/unit/ard/api/inputs_onshore/windio.yaml b/test/ard/unit/api/inputs_onshore/windio.yaml
similarity index 100%
rename from test/unit/ard/api/inputs_onshore/windio.yaml
rename to test/ard/unit/api/inputs_onshore/windio.yaml
diff --git a/test/unit/ard/api/test_interface_unit.py b/test/ard/unit/api/test_interface_unit.py
similarity index 94%
rename from test/unit/ard/api/test_interface_unit.py
rename to test/ard/unit/api/test_interface_unit.py
index c75339de..4ea3b784 100644
--- a/test/unit/ard/api/test_interface_unit.py
+++ b/test/ard/unit/api/test_interface_unit.py
@@ -1,7 +1,5 @@
 import pytest
-import numpy as np
-import ard.layout.spacing
-import openmdao.api as om
+
 from pathlib import Path
 from ard.api import set_up_ard_model
 
diff --git a/test/unit/ard/api/test_multiobjective.py b/test/ard/unit/api/test_multiobjective.py
similarity index 100%
rename from test/unit/ard/api/test_multiobjective.py
rename to test/ard/unit/api/test_multiobjective.py
diff --git a/test/unit/__init__.py b/test/ard/unit/collection/__init__.py
similarity index 100%
rename from test/unit/__init__.py
rename to test/ard/unit/collection/__init__.py
diff --git a/test/unit/ard/collection/test_optiwindnet.py b/test/ard/unit/collection/test_optiwindnet.py
similarity index 100%
rename from test/unit/ard/collection/test_optiwindnet.py
rename to test/ard/unit/collection/test_optiwindnet.py
diff --git a/test/unit/ard/collection/test_optiwindnet_pyrite.npz b/test/ard/unit/collection/test_optiwindnet_pyrite.npz
similarity index 100%
rename from test/unit/ard/collection/test_optiwindnet_pyrite.npz
rename to test/ard/unit/collection/test_optiwindnet_pyrite.npz
diff --git a/test/unit/ard/collection/test_templates.py b/test/ard/unit/collection/test_templates.py
similarity index 100%
rename from test/unit/ard/collection/test_templates.py
rename to test/ard/unit/collection/test_templates.py
diff --git a/test/unit/ard/collection/__init__.py b/test/ard/unit/cost/__init__.py
similarity index 100%
rename from test/unit/ard/collection/__init__.py
rename to test/ard/unit/cost/__init__.py
diff --git a/test/unit/ard/cost/test_landbosse_wrap_baseline_farm.npz b/test/ard/unit/cost/test_landbosse_wrap_baseline_farm.npz
similarity index 100%
rename from test/unit/ard/cost/test_landbosse_wrap_baseline_farm.npz
rename to test/ard/unit/cost/test_landbosse_wrap_baseline_farm.npz
diff --git a/test/unit/ard/cost/test_orbit_wrap.py b/test/ard/unit/cost/test_orbit_wrap.py
similarity index 100%
rename from test/unit/ard/cost/test_orbit_wrap.py
rename to test/ard/unit/cost/test_orbit_wrap.py
diff --git a/test/unit/ard/cost/test_orbit_wrap_baseline_farm.npz b/test/ard/unit/cost/test_orbit_wrap_baseline_farm.npz
similarity index 100%
rename from test/unit/ard/cost/test_orbit_wrap_baseline_farm.npz
rename to test/ard/unit/cost/test_orbit_wrap_baseline_farm.npz
diff --git a/test/unit/ard/cost/test_spacing_approximations.py b/test/ard/unit/cost/test_spacing_approximations.py
similarity index 100%
rename from test/unit/ard/cost/test_spacing_approximations.py
rename to test/ard/unit/cost/test_spacing_approximations.py
diff --git a/test/unit/ard/cost/test_wisdem_wrap.py b/test/ard/unit/cost/test_wisdem_wrap.py
similarity index 100%
rename from test/unit/ard/cost/test_wisdem_wrap.py
rename to test/ard/unit/cost/test_wisdem_wrap.py
diff --git a/test/unit/ard/cost/__init__.py b/test/ard/unit/farm_aero/__init__.py
similarity index 100%
rename from test/unit/ard/cost/__init__.py
rename to test/ard/unit/farm_aero/__init__.py
diff --git a/test/unit/ard/farm_aero/test_floris.py b/test/ard/unit/farm_aero/test_floris.py
similarity index 100%
rename from test/unit/ard/farm_aero/test_floris.py
rename to test/ard/unit/farm_aero/test_floris.py
diff --git a/test/unit/ard/farm_aero/test_floris_aep_pyrite.npz b/test/ard/unit/farm_aero/test_floris_aep_pyrite.npz
similarity index 100%
rename from test/unit/ard/farm_aero/test_floris_aep_pyrite.npz
rename to test/ard/unit/farm_aero/test_floris_aep_pyrite.npz
diff --git a/test/unit/ard/farm_aero/test_floris_batch_pyrite.npz b/test/ard/unit/farm_aero/test_floris_batch_pyrite.npz
similarity index 100%
rename from test/unit/ard/farm_aero/test_floris_batch_pyrite.npz
rename to test/ard/unit/farm_aero/test_floris_batch_pyrite.npz
diff --git a/test/unit/ard/farm_aero/test_templates.py b/test/ard/unit/farm_aero/test_templates.py
similarity index 100%
rename from test/unit/ard/farm_aero/test_templates.py
rename to test/ard/unit/farm_aero/test_templates.py
diff --git a/test/unit/ard/geographic/test_geomorphology.py b/test/ard/unit/geographic/test_geomorphology.py
similarity index 100%
rename from test/unit/ard/geographic/test_geomorphology.py
rename to test/ard/unit/geographic/test_geomorphology.py
diff --git a/test/unit/ard/geographic/test_geomorphology_depth_default_gradients_pyrite.npz b/test/ard/unit/geographic/test_geomorphology_depth_default_gradients_pyrite.npz
similarity index 100%
rename from test/unit/ard/geographic/test_geomorphology_depth_default_gradients_pyrite.npz
rename to test/ard/unit/geographic/test_geomorphology_depth_default_gradients_pyrite.npz
diff --git a/test/unit/ard/geographic/test_geomorphology_depth_default_pyrite.npz b/test/ard/unit/geographic/test_geomorphology_depth_default_pyrite.npz
similarity index 100%
rename from test/unit/ard/geographic/test_geomorphology_depth_default_pyrite.npz
rename to test/ard/unit/geographic/test_geomorphology_depth_default_pyrite.npz
diff --git a/test/unit/ard/layout/.gitignore b/test/ard/unit/layout/.gitignore
similarity index 100%
rename from test/unit/ard/layout/.gitignore
rename to test/ard/unit/layout/.gitignore
diff --git a/test/unit/ard/farm_aero/__init__.py b/test/ard/unit/layout/__init__.py
similarity index 100%
rename from test/unit/ard/farm_aero/__init__.py
rename to test/ard/unit/layout/__init__.py
diff --git a/test/unit/ard/layout/test_boundary.py b/test/ard/unit/layout/test_boundary.py
similarity index 100%
rename from test/unit/ard/layout/test_boundary.py
rename to test/ard/unit/layout/test_boundary.py
diff --git a/test/unit/ard/layout/test_fullfarm.py b/test/ard/unit/layout/test_fullfarm.py
similarity index 100%
rename from test/unit/ard/layout/test_fullfarm.py
rename to test/ard/unit/layout/test_fullfarm.py
diff --git a/test/unit/ard/layout/test_gridfarm.py b/test/ard/unit/layout/test_gridfarm.py
similarity index 100%
rename from test/unit/ard/layout/test_gridfarm.py
rename to test/ard/unit/layout/test_gridfarm.py
diff --git a/test/unit/ard/layout/test_spacing.py b/test/ard/unit/layout/test_spacing.py
similarity index 100%
rename from test/unit/ard/layout/test_spacing.py
rename to test/ard/unit/layout/test_spacing.py
diff --git a/test/unit/ard/layout/test_sunflower.py b/test/ard/unit/layout/test_sunflower.py
similarity index 100%
rename from test/unit/ard/layout/test_sunflower.py
rename to test/ard/unit/layout/test_sunflower.py
diff --git a/test/unit/ard/layout/test_sunflower_4D_pyrite.npz b/test/ard/unit/layout/test_sunflower_4D_pyrite.npz
similarity index 100%
rename from test/unit/ard/layout/test_sunflower_4D_pyrite.npz
rename to test/ard/unit/layout/test_sunflower_4D_pyrite.npz
diff --git a/test/unit/ard/layout/test_sunflower_7D_pyrite.npz b/test/ard/unit/layout/test_sunflower_7D_pyrite.npz
similarity index 100%
rename from test/unit/ard/layout/test_sunflower_7D_pyrite.npz
rename to test/ard/unit/layout/test_sunflower_7D_pyrite.npz
diff --git a/test/unit/ard/layout/test_templates.py b/test/ard/unit/layout/test_templates.py
similarity index 100%
rename from test/unit/ard/layout/test_templates.py
rename to test/ard/unit/layout/test_templates.py
diff --git a/test/unit/ard/layout/test_viewshed.py b/test/ard/unit/layout/test_viewshed.py
similarity index 100%
rename from test/unit/ard/layout/test_viewshed.py
rename to test/ard/unit/layout/test_viewshed.py
diff --git a/test/unit/ard/offshore/test_mooringconstraint.py b/test/ard/unit/offshore/test_mooringconstraint.py
similarity index 100%
rename from test/unit/ard/offshore/test_mooringconstraint.py
rename to test/ard/unit/offshore/test_mooringconstraint.py
diff --git a/test/unit/ard/offshore/test_mooringdesign.py b/test/ard/unit/offshore/test_mooringdesign.py
similarity index 100%
rename from test/unit/ard/offshore/test_mooringdesign.py
rename to test/ard/unit/offshore/test_mooringdesign.py
diff --git a/test/unit/ard/test_wind_query.py b/test/ard/unit/test_wind_query.py
similarity index 100%
rename from test/unit/ard/test_wind_query.py
rename to test/ard/unit/test_wind_query.py
diff --git a/test/unit/ard/utils/test_geometry.py b/test/ard/unit/utils/test_geometry.py
similarity index 100%
rename from test/unit/ard/utils/test_geometry.py
rename to test/ard/unit/utils/test_geometry.py
diff --git a/test/unit/ard/utils/test_io.py b/test/ard/unit/utils/test_io.py
similarity index 100%
rename from test/unit/ard/utils/test_io.py
rename to test/ard/unit/utils/test_io.py
diff --git a/test/unit/ard/utils/test_matematics.py b/test/ard/unit/utils/test_matematics.py
similarity index 100%
rename from test/unit/ard/utils/test_matematics.py
rename to test/ard/unit/utils/test_matematics.py
diff --git a/test/unit/ard/utils/test_utils.py b/test/ard/unit/utils/test_utils.py
similarity index 100%
rename from test/unit/ard/utils/test_utils.py
rename to test/ard/unit/utils/test_utils.py
diff --git a/test/unit/ard/layout/__init__.py b/test/ard/unit/viz/__init__.py
similarity index 100%
rename from test/unit/ard/layout/__init__.py
rename to test/ard/unit/viz/__init__.py
diff --git a/test/unit/ard/viz/test_plot_layout.py b/test/ard/unit/viz/test_plot_layout.py
similarity index 100%
rename from test/unit/ard/viz/test_plot_layout.py
rename to test/ard/unit/viz/test_plot_layout.py
diff --git a/test/unit/ard/viz/test_utils.py b/test/ard/unit/viz/test_utils.py
similarity index 100%
rename from test/unit/ard/viz/test_utils.py
rename to test/ard/unit/viz/test_utils.py
diff --git a/test/run_local_test_system.sh b/test/run_local_test_system.sh
index ea908eba..28729015 100644
--- a/test/run_local_test_system.sh
+++ b/test/run_local_test_system.sh
@@ -1,10 +1,10 @@
 #!/bin/bash
 if python -c "import optiwindnet" 2>/dev/null ; then
-  pytest --cov=ard --cov-report=html test/system
+  pytest --cov=ard --cov-report=html test/ard/system
 else
-  pytest --cov=ard --cov-report=html test/system --cov-config=.coveragerc_no_optiwindnet
+  pytest --cov=ard --cov-report=html test/ard/system --cov-config=.coveragerc_no_optiwindnet
 fi
 
-rm -rf test/system/layout/problem*_out
+rm -rf test/ard/system/layout/problem*_out
 
 #
diff --git a/test/run_local_test_unit.sh b/test/run_local_test_unit.sh
index 65646045..a64346a7 100644
--- a/test/run_local_test_unit.sh
+++ b/test/run_local_test_unit.sh
@@ -1,10 +1,10 @@
 #!/bin/bash
 if python -c "import optiwindnet" 2>/dev/null ; then
-  pytest --cov=ard --cov-report=html test/unit
+  pytest --cov=ard --cov-report=html test/ard/unit
 else
-  pytest --cov=ard --cov-report=html test/unit --cov-config=.coveragerc_no_optiwindnet
+  pytest --cov=ard --cov-report=html test/ard/unit --cov-config=.coveragerc_no_optiwindnet
 fi
 
-rm -rf test/unit/layout/problem*_out
+rm -rf test/ard/unit/layout/problem*_out
 
 #
diff --git a/test/unit/ard/viz/__init__.py b/test/unit/ard/viz/__init__.py
deleted file mode 100644
index e69de29b..00000000

From 76826648b5e51456fa5fdca1334ded902bb44430 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Thu, 8 Jan 2026 11:32:49 -0700
Subject: [PATCH 09/30] fix logomaker (#166)

* fix logomaker

* black reformat
---
 ard/farm_aero/templates.py              |  18 +-
 assets/logomaker/inputs/ard_system.yaml |   2 +
 assets/logomaker/logo.png               | Bin 48656 -> 48486 bytes
 assets/logomaker/logomaker.ipynb        | 598 ++++++++++++++++++++++--
 4 files changed, 573 insertions(+), 45 deletions(-)

diff --git a/ard/farm_aero/templates.py b/ard/farm_aero/templates.py
index 4deeaa26..6f4da7b0 100644
--- a/ard/farm_aero/templates.py
+++ b/ard/farm_aero/templates.py
@@ -329,7 +329,11 @@ def setup(self):
             units="W",
         )
 
-        if self.options["modeling_options"]["aero"]["return_turbine_output"]:
+        if (
+            self.options["modeling_options"]
+            .get("aero", {})
+            .get("return_turbine_output")
+        ):
             self.add_output(
                 "power_turbines",
                 np.zeros((self.N_turbines, self.N_wind_conditions)),
@@ -365,7 +369,11 @@ def compute(self, inputs, outputs):
 
         # the following should be set
         outputs["power_farm"] = np.zeros((self.N_wind_conditions,))
-        if self.options["modeling_options"]["aero"]["return_turbine_output"]:
+        if (
+            self.options["modeling_options"]
+            .get("aero", {})
+            .get("return_turbine_output")
+        ):
             outputs["power_turbines"] = np.zeros(
                 (self.N_turbines, self.N_wind_conditions)
             )
@@ -456,7 +464,11 @@ def setup(self):
             np.zeros((self.N_wind_conditions,)),
             units="W",
         )
-        if self.options["modeling_options"]["aero"]["return_turbine_output"]:
+        if (
+            self.options["modeling_options"]
+            .get("aero", {})
+            .get("return_turbine_output")
+        ):
             self.add_output(
                 "power_turbines",
                 np.zeros((self.N_turbines, self.N_wind_conditions)),
diff --git a/assets/logomaker/inputs/ard_system.yaml b/assets/logomaker/inputs/ard_system.yaml
index 6ae83c0c..aab9f256 100644
--- a/assets/logomaker/inputs/ard_system.yaml
+++ b/assets/logomaker/inputs/ard_system.yaml
@@ -4,6 +4,8 @@ modeling_options: &modeling_options
     N_turbines: 25
     N_substations: 1
   site_depth: 200.0
+  aero:
+    return_turbine_output: True
   collection:
     max_turbines_per_string: 8
     solver_name: "highs"
diff --git a/assets/logomaker/logo.png b/assets/logomaker/logo.png
index 951dc8a7865a3d146495ee076955dd3f852cf733..e763933a4bdffa3d8ae1976be8cc5fab0f309840 100644
GIT binary patch
literal 48486
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

literal 48656
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
RM!B@tz*^%DGWHX${SPn+6L0_k

diff --git a/assets/logomaker/logomaker.ipynb b/assets/logomaker/logomaker.ipynb
index da6ab852..8afacb92 100644
--- a/assets/logomaker/logomaker.ipynb
+++ b/assets/logomaker/logomaker.ipynb
@@ -5,16 +5,7 @@
    "execution_count": 1,
    "id": "48df93d4",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "RuntimeWarning: <frozen importlib._bootstrap>:488\n",
-      "numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path\n",
     "import yaml\n",
@@ -141,7 +132,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -176,7 +167,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQC1JREFUeJzt3Qd4nVX9B/Bv1k1ys272Hk3SvfemQMsqyEYtyJChbAQVQYYgin8RREBEEVBEEFkCpQVKaRmFtnTvtGnS7D1u1r3JvbnJ//mdNC2jLWmb5L7vPd/P8+SpgrbvfXvO737f857h193d3Q0iIiLSlr+3L4CIiIi8i2GAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDTHMEBERKQ5hgEiIiLNMQwQERFpjmGAiIhIcwwDREREmmMYICIi0hzDABERkeYYBoiIiDQX6O0LICIiGmgOlwcPf1qGDk83jGhYXCgun5TotT+fYYCIiHze0+uq8KsPS5AUHgSjcXm60eDsxJzMSOTEhnrlGhgGiIjI53m6uhFm8cfT5w2F0eyobsOdy4rh6fbeqAXnDBAREWmOYYCIiEhzDANERESaYxggIiLSHMMAERGR5hgGiIiINMcwQEREpDmGASIiIs0xDBAREWmOYYCIiEhzDANERESaYxggIiLSHMMAERGR5hgGiIiINMcwQEREpDmGASIiIs0xDBAREWmOYYCIiEhzDANERESaYxggIiLSHMMAERGR5hgGiIiINMcwQEREpDmGASIiIs0xDBAREWmOYYCIiEhzDANERESaYxggIiLSHMMAERGR5hgGiIiINMcwQEREpDmGASIiIs0xDBAREWmOYYCIiEhzDANERESaYxggIiLSXKC3L4COrLXDg3qHG/b2TrR0eOBwd8Hl6YKnq+ffB/gDwQH+sFr8EWEJhC00AHHWIFgtAV67Zk9XN97d03DgGgkICvDD6UOj4e/v57VraHP1tKVGZ09bcrq70HGIthQa5I+I4ABEhwYi1hqEMC+2JTImh8uDOqlLTg9aXJ1wuL7ZlixSl/a3JVtIT1sKD2ZbMiqGAS+TL878Oid21jiwu86JvfVOFDa0o7SpA5UtLvXlfyzCLP5IibAgIyoY2bGhyIkJwfD4UIxJDEN2dMiAfik99nk5frp034D9/mb1l7NzcN2MlAFtSwUNTuyo/lpbsve0pbZjbUtB/kiOsCDdFozsmBDkxoZieFwoRidakRMTigAvBhwaGF1d3ShsbMf26jbsrnWioKEdBfVOVZcqpC25jq0tWXvbUtRX29KoBCuGxrEteRPDwCArbmzHquJmrC5pxrqyFmyrcsDZ2dOxwi0BSIm0ICEsCGOTrJg3JEol6qiQANWJ5Gk/OMAPgf5+8Pfr6TRd3d1wd3Wjo7MbDnfPyEFTeyfs7R40ONyobXNjZaEdL24+GCzk9xqfHIZpaRGYmRGJOZmRSI0K7rfPWO/oRGJ4EB4+Y0i//Z5md9PiAnVf+pN8ya8qbsLqkhZ8odpS24G/43AJg5HBiA8LUl/aJ+xvS5EhAerLPTQoACGB32xLnV3daO/shtPtUeGhud2jRqVkRKHO0YlPi5rx3621aHUdbEtjk3rbUgTmZEap0EDmUt7UcaAuSVvaUnmwLcnfcW9dki/tOVnSlgIQFRLYU5eCAhAc6IegQ7SlDk+3GkXoqUs9banB6UZdW6f6817ZVodWl0f9f0IDpS1ZMfVLdSkzOsSr90UnDAMDTL6QP9hrx/v5jVi+txGlTS71z9MiLSoVXzw+HlnRwciwhagO5re/M/W37u5uNDg7UWLvwL7GdpX0pSM+9nmF+vcyWrAg14bThkarXyNDjq9pSMCXYkE9eovk8bA7O/HB3kYsy7ertlRk71D/PFXaUkwIvjcuHkOkLUUFqyH+gWxL8qqhpEnaUgcK6514Y0cdnljd05aybMFYkBuNU4facEpuNGyhbAdG09zeieUH6pJdjQIIeWrPjQ3Bd8fGYUh0CDJswYgZ4LYkDy4l9nYUNXaouvTWzno8uaZS/fv0KItqS1KXTsm1IcYaNCDXQQwDA5ayX9tepwrkZ8XN8HQDmbZgTEgOx6UTwzAqIRSRwYN766Uzyzs7+ZmYEn7gn0tR31XjwNbqNizd3YCn11WphC9PkheMjsX5o+OQGGEZ1GulgyqbXXh9R09b+mRfk2pLUqDHJYZh0fh49aQ22KFL2pIUZfmRNt1LRqTkdZeMdi3b24hn1lepkYe5WZGqHV0wOg7JkWxL3lLd4lLt6PUd9fh4X5N6cpeHknHJYerLf2SCVYXIwW5L8mdGh4Zj/JfaUnOHtCWnGu1aUWDHPzZUI8APmJ3Z05YuHBPXr6OZxDDQr0lbnrT/takaq4qaVRGUofgfT0vGlNRwxIUZM9FKR5yVGal+RFWLC+vLW9VQoQxt37i4ACdn23DZpATVCTmZbOC1dHTi9e31qi19VNgEf39gfFI4rpmapNpSQrgxv1AllMjwrvyImtbettSKnywpwM2LC3BidhQum5ioijknkw3OpFEJAP/aWIMVhXbI87281rlycqJqS0kGDfrysDQjPUL9iLo294G69LN39+HWJYWYkxWp2pIEmeMdySSGgeMm7/2fWlup3qPK7OwJyWG4eVaKasRm/OKU4nDWiBj1IwHn85IWfFLUhMte3YPr3yrADybE4/oZKaqgUP/aVNGq2tJLm2vUO1a5xzfMSMasjEhTfnFKaFk4PEb9yOoFeR/9SVEzrnx9D258ey8unpCA66Ynf2WkivrH1so2PLW2Av/eLPM7PBiTaMW105IxKzNi0Ecl+4M8TJ0+LFr9yOdZW9qiRjd+9L983PJOgXpFJm1J5hvQsTFfqzCATk83Xttei0c/K1dPPTJZ7rxRsZifYzPsCMCxkLTd2wFlxGB5gR2vbq/DX7+owglZkbhtThq+MyLGq8vlzE5WALy5sx5/XFWmgpdM+PvOyBgsyLEZdgTgWMjyslOHyjyCaDViIG1JPvff11VhVkaEakvnjorlbPLjXAGwOK9BtSUJXbHWQCwcHq3aklFHAI6FTLSWWis/MmLwYYFdveKUVwnT0sJx6+xUXDgmHoHyXoH6jGHgKHR0dqkG9/uPS9XkLXkNcPeJ6ZicGu7zRUyKyQ8mJOD74+KxprQF7+Q14Nx/71TLgu6Yl45LJsQjSBYXU5+4Orvwr001+L+PS9WkqbGJVtw5L03Nyvf1tiQh5+LxCfje2HisLWvBkrwGXPjSLrX8VdrSZRMTYAlkW+ort6cLL26uVW1JlpTKPJLbT0hTo5PyutKXycOXjArIa6cN5a1YvLsBi/67G3e+X4RfzEvHDycnIphtqU8YBvrY2Z5dX40HVpSo9dryruons1PVOlndSHGRJT/yk1frUO+2f/j6Hvx6RTHum5+JSyYkePsSDT+q9Pymatz/YTHKmlzq/fr1M5IxNDYUupHQI69A5Ce/3onXt9fhmv/lq3527/wMXD4xkU933zKq9OLmGtz3YbFa1TE9LQIPnZ6FEfFW6NiWpqVHqB/Za+ONHfW4/q29+M3KEtx9UgaumpLo7Us0PL9uWdtBhyS3RgrUHe8Xqc1bThgSqZ5m0jiL9Sv2NbTjP1tr1YiBPJVYAvzUa4Wnzxvq7UszjCte26PCY3OHB3vqnGpW9KJxcWpJKR0kS8z+s7VnFc6wuFA8dPoQnD0yZsCWtpm1Lr27pxE/f3efWr0hIwCLZFmphg8nR1LW1IGXt9aqvTGk78kruK1VbXj5+yNgNDuq23DnsmLsvm0yhsV5J8wxDBxhMpfMppeiJK8BLp+YgCxugHFEspPiPzdWY1u1Q/33ty8d5e1LMoyzX9ipfpUJppdPSlA799HhydPd8xtrsLmyDScOicLj38nhpFVALQOWCXOyd8m4JKsaPZGd++jwihrb8fymGvUawah1aQfDgPHIDPq7lhXhL2sr1ZaZsgSHs537TpqTLAGS0RPZwIQOPqXUtLkxMTmMT7lH0ZY2VLTiuQ3Var+FW2an4v75maZcWXG8ZBe/X68owSOrytVOgFdMTsT0tHC2paOwubJVbaBkxNG4HQwDxrJ4Vz2ufXOv2ohHNnSR5XW+PgGHyOjcnp4VF69sr1VfhH8/bxhOGxYNXcimO1e/sQflzS41Ue780bHqECDyHTsMEAbYovZv83rZK3lqKFd2SPvz2TlqmRODAJExTny8aGwcnjgrR+2gefo/t+Oq1/eozZl8fcOgG97ai/nPblN7ljx2VrZazcMgQANB+9UEssXrJf/NU6MBt8xKwcnZURx6IzLo8tb752fg/fye7WllR73/fG8EZuzf8dCXbChvwaKX89T5Dz+amqT2C+iP8y2IDsdf5w06ZAnTSc9sVduoSuqWTSwYBIiMS/qnbIL1p7OyERzgjzl/24KHPilV/dkXyFvbxz4rx8yntkA+0aMLs9XrSgYBGmiBup4kuOi/efgg347vjYtTywV9faMXIl8ik1N/d1qWWmf/i/eK1HkgL3x3uKlPypTXHj98bY86SOickTFq3315RUI0GMzbc46RnIJ19gs70OjoxH3zM7hSgMikZE7P5ZMS1d4Wj35WgSlPbsLiS0djRIL5Nt3ZW+/E2f/agWJ7h9qJsvewJ6LBotVrAtn2dOZfN8Mffnhk4RAGASIfIIfTPHzGELg83Zj+1GZ8kN8IM/m40I6pT25SG1LJ52AQIG/QJgw8taZCjQiMTQxTw4u+dAgMke5SIi146LQsta3zwud34Ln1VTADOaHylOe2I9MWgj+cPoS7m5LX+HwYkAk593xQhOvfLsCZw2PwixPSEBrk8x+bSDtWSwDuPikd83OicNUb+XjwoxLV/41KThe85JXdmDskEveenKHlZkpkHD49Z0BmGMvWnX9eU6m2gD1/VCxXCxD5MJkIfP30ZMSEBuGuZcWwOz34/elZhur3ElB+tbwYD6wsxQWjY9UpjUa6PtJToC8HgR+9mY/n1ler4iDLkYjI98kXq+wgGm7xxx8+LUN7Z5daOmyEL1wJArL6Qa5LHlAuGB3n7Usi8t0wIEHgx/uDgNpIKMfm7UsiokH2nZGxCArwxxOrKyAx4E9eDgQSBOQEVAkC10xJVNdHZBQ+Fwakw926pBDPrq/GzQwCRFrrHRF8fHWFmiv0f6cP8dq1yEFDD31ShqsZBMiAfC4MSIeTjn/d9CS1oyAR6U0CQUdnF37/SRlirIG4/YT0Qb+GJz4vx30fluDSCQk4m0GADMinwsDf11WqDveDCfE4Y1iMty+HiAzinFGxaOnwqPf1KRHB+MHEhEH7s1/dVotb3inEuaNicOEYBgEyJp8JA8vyG3Hdm3uxcFg0LhrDSTlE9FWXTIhHvdONK1/fg/QoC+ZlD/zI4ZqSZlwqywezInHFpERDTGIkOhSfWHCfV+PAhS/tUjsKXjM1iR2OiL5B6sINM1LU9sXnvbgLBfXOAf3zSuzt6lj0nNhQNZGZhw2RkZk+DDS1d6qdBaNDA/GzOak8cIiIjniewe37Nx4754WdaO3wDMif43R7cO6/d0LKkZw1IKsaiIzM3+wrBy57dTcqW1z45bx0tQMZEdGRRAQHqHpR2NCOa/63Z0B2Kbz+rb3YWePAnfPSTX2SIunD1GHg0c/K8fauBvxkVqram5yIqC8ybMG4aWYyXt5ah7+urezX3/ufG6rxz401uG5aMrJjQvr19yYaKKYNA+vLWtTM4PNGxWJaeoS3L4eITGZOVhQWDo9W+5LI0eb9NX/phrf34pRcG/c4IVMxZRhoc3mw6L95GBIdjB9MGLwlQkTkW66cnKhGFb//ch7a3V3H9Xu5Ortw8St5ai+Da6Yk9ds1Eg0GU4aBX7y3D6VNHbhtTiqCAjhhkIiOjSXAH7fOTkV+nRP3LC86rt/rNytLsLWqDbfNTkUIT0YlkzFdi/2o0I4n5RTCiYlIjeTZ30R0fLKiQ3Dx+Hg88mm52hfgWGyqaMWDH5Xiu2PikRsb2u/XSDTQTBUGZLnO1W/kY3SCVb3rIyLqD+eOisXQuFBc9Ua+Gu4/Gp2ebrWRUYYtBBdywzMyKVOFAUnexfYO3DAjmRt4EFG/kf1JbpiejN21Djyyqvyo/r9/XlOBLZVtqi7xtSWZlWkWwMo7PTnx6/zRsUiL0vf1gNvTrc5nd3u61I5qsomKbKAivxIdS1vq7OpZZy9tKCTQX9svtCExIThrRAweWFGiti6WJ/1vU9nswj0fFOOMYdEYFqfv6wFpQ053T1uSfRtkkyWd25IZmSYM3La0ELaQQC3OHfB0daPI3o699e0oamxHRbMLNW1uNDg7VYc7lDCLP2JDgxAfFqRmRw+JDkFubAjSo4K5K6PGpC2V2DuQX+9Uo2rlzS7UtrlR73DDcZi2ZA3yR6y1py2lRlqQaQvG0NhQtTbf19vSovHx+LSoGbe/uw8vLxr5rf/7O9/fp3YZ1GFVk7QlmbgtdWnf/rqk2pLTjTbXoduSPKjEhAYiYX9dytpfl7JsIT7flszGFGFgRYEd7+Q14OdzUxEcaKo3G31W1+bG2rIWbCxvxY4ahyrU0lekCI+MD8WJ2TZVmOPCghBhCYAlsKcjdXR2o7mjE3VtnShv7lC7qu2qcaj7Jc974ZYAjEm0YlJKOKanR6htm8m3yRf9F6ottWF7TZsq1NKWcmJCMDLeihOGRKrJt3HWIEQGH2xLLtWWPKhzuHvaUn07dtU6sGR3A2TwQALnmIQwTEoNw7S0CBUYfI01KACXTkzAY59X4JbZzZiZEXnY/6301ec31eDaaUkID/bN3U8bnZ1YW9qCjRWt2F7tQKvLA2ktqi0lWDEna39bCgtEZHAggr/UllpcHlXXJIDua3BiV60T7+5pVG1JAqfM/ZqUGo7paRGqrpF3+XUPxF6c/airqxtT/7JJfTn+/rQsnzqESNY1f1LUhJWFTSoAyDDtnMxInDLUhhOyotQX+LFusSx7rq8ra8GnRU1YtteO1SXNkL/pcclhODk7CrMzI9WyKvINHZ1dWFXcjJWFdmyrcqgv/1mZkTg1NxonDInC5NRwhB1jW5J9PTaUt+KTfdKWGvF5cbMq6GOTrDgp26barC+F9K7ubty2ZB+SIixY9eNxh605C57dhj11Tjx+VrZPPeW6PF34rLgZKwqbsLWyDfLxJRSdmmvD3KwoTE2LOObw43B5VLCQuvdBvl21WXm1IMHgpOwoVfd0XJa5o7oNdy4rxu7bJmNYnNUr12D4MPDatlpc9J88PHhqJsYkhsFXntxkG+UP9jaqp7YFuTY1zHj2yFjYBujJXRL6mzvr8cKmanxS1Iyo4ACcNiwaZw2PGbA/kwbnye3tXfUq8LV0eFRBlSfbc0bGImaAntwbHG68tUvaUo0KsrLXv3xRSPv1lZEn+cK678MSvHPZaJw5IuaQo5Xzn92GX85Lw4wjjB6Yid3ZiXd2N+D9PY1o6vDghKxIXDoxUa20GKgnd/v+9vvvzTVYvteuRp9OyY3G2SNjfHLk6XAYBvowKjD28Y0ICfTDffMzYXbS8F/ZVof38xvVu7RrpyfjuunJ6j3aYNpT58CTqyvxzPoq9YR35vBoXDA6zmeHOn2RvBp6dVsd3tvTqCZr/WhaEq6fnqyOyx1McgzwX9ZW4ukvqtSk1tOHReOisXFqyNjMpCz+clmxGvZef8PEr4wOyL+b+/RW1LS68PAZQ0w/WimjiK/vqMOS3Y1qROnqKUm4YWbyoH8pyfyop9ZWqrMiZG7UaUOj8d2xcVo8rOxgGDiy17fX4cKXduGh07MwIt47N6g/yDDY4l31+O+2ugNHqN40MwWRXj7NTEYoHl1Vrg58kuuSjVekA/rSkKcvTuJaursB/9lap/77T+ek4pbZKYgO9e5TVKPTjcc+qziwLG/RuDgsHB5j6ra0pbIV9ywvwdLLR+OM4QdHB1YW2HHys9twz0npasjczG1JHkxe2lKrapTsxHjrnFSvP5HLsfR/Xl2hVo/JdX1vbBy+MzLWp1dM7WAYODy5rClPboKnC3jgFPOOCsiT0+OrK1Fsb1dPbvctyPR6Z/u6KjkCelkR/rGhGsPjQnHzrBS1CoGMRWZwS5GU2dwyEvDAgkzEhxvrtM7aVhfuWV6sRgpk1viNM1PUyhYzkhr0i/eL1ETLT388/sA/P+XZberv4o8LzTsqIKsCHv+8ArvrnPjh5EQ8eGqWmiNhJPKwct/yYjXylGkLwc0zB3/kS6cwYNiZGh8VNmFjRZvaV8Csk5BkGPdn7+1TM7bXXT8RT5yda7ggIKQIPHfBMDVZSpKhnOImM8gNmhO1I21J5nv8dOk+9UpgzXUT8NdzhxouCAi5Jrm21deNV9f6s6X71LWbsS3JF/35o+PUJLe1pc0HRguWF9jVaalmDALy9yB9W/q4/I1In5e+b7QgIKRWSs2U2ik1VGqp1FTpD6RRGJCh6yxbMCYkh5nyHdwDK0vVpJjb56bji+snqCU0Rjc7Mwqbb5qIH01Nwt++qMIfPi0/7L4GNDhk9vX/fVyG5zZUqxGbjTdONMWR3dPTI9W13jQrRV377z4uU5/FbKalhav18X/6rOf1x58+q1Br5mU1jtlIX5Y+LX1b+rj0denzRie1U2qo1FKpqVJbpcaSBmFAJpLIOnmZxWu29F3R3IGfv7dPrfd/94oxePC0LFhMtOwqNChApfHXLh6JTZWtuPP9IrUSgbzz+ub294uws8aBty8dhUcWZptqCZ9cq1yzXLt8Bvks8pnMRLY9XzgsGq9tr8f2qjb8Z0uN2m3QbHMhpA9LX5Y+LX1b+rj0dbOQGiq1VGqq1FapsVJrqf8YsrL8fV2VWmIyL8v4qfXLZJc3ecco67nXXT9BLd0zqwvGxGH1tRPg7upSn0neMdLgkXfSd7xfBNnNde11E9QEKrOSa5fPIJ9FPpN8NjOZn2NTk9dkBYGsvjkl1wYzkb57+3v7VF+WPi1926ykpkptlRordUlqLvloGJATwJ5bX2W6zSfyah2494Niteph9bXjfWKiy9ikMPV+WoZFZYKhjNjQ4Ew6vfuDYrUNsNz/EQnmXUnTSz6DfBb5TPLZ5DOahXzxyGsBe3snZmREeH0V0NGQPit9V+YEyP2XPm12Uls/v3a8qrVSc6X20vEz3Let7HBW1eo2VfqWwnb/hyWYmBKO5VeOHbDNXrwhJTIYH/9onJoRfu/yYpRxhGBAFTe2494PS9QW1CuvGYcEA04SPFbyWeQzyWeTzyif1Sx669GCHPPUJemr0mel7350zTjVl32FTC6UWis1V2qvmcKlURkuDPx7U416esiOMcdyJHkH+usVpRiVaMXSK0b75MY9quNdNRbJERbcv6JE7UBH/U8OfblvRQmyo0Pw/g/HIspET6B9JZ9JPpt8Rvms8pnNYFSCVc19kC8fM5A+KjsoSp+VvmvEVUzHS2qt1FypvVKDzTYfxWgMFQZktrFsczo3K9IUEwflen+zshQx1kAsvXwMIky+69qRSDGRIi4TqmRmuOxfTv17TsVvV5aqA1ze++EYn951TT6bTASTzyqfWT479R/pmw9+XKYmOUqf9cUg0Etq7pLLRqsaLLXYjCtWjMJQYUBOtJIDieaYYLmLrNd9bHUFGts7seTy0VqcupVuC8biy0apDZRkeRL1X1v685oKVLe6sOTyMYZc893fkiMt6rPKZ5bPbsZ9CIxK+maJvV31Vemzvk72tpAaLLVYajLbkg+Egf/trFPvt2Rdr9HJPt6rS1rwwkXDMdzEWyUfrcmpEXjqnKH4YK9dbQxFx0/upRwe9ewFw3xigldfyWeVzyyfXe4BHT/pk3IvpY9KX9WF1GCpxVKTpTaTicOArCJYursRU9PCTTEx558bq9X5AueMMu+Sr2N1xeREXDI+Hn/7otI073yNSt5zPrO+Wh0O871x8dCNfGb57M+ur+Y73+MkfVH6pPRN6aO6kVosNfn5jdWc6GzmMPBFWYs6jnWKwXfqk60wn1hdoSY5/v70LOjqz2fnqiVWcsIYh+WOjdy3J9dUIjE8CI+emQ1dyWdPCA9S94Jt6djIfZO+KH1S+qaupCZn2IJVjea2xSYNA8vyGxFuCcBQg6/PlzO3d9U68ffzhppqB6+BmAT2l3NysK68FWtKW7x9OaYkw+Nbqtrwt3OH+uQqlL6Szy73QO6F3BM6etIHpS9Kn/TlyaffRmqy1Gap0VKryYRh4MMCO8YmWQ29zafD7cGLm2vVMNy8bPOsNx4o54yMVUceyysTt4cp/Gh0dHbhX5tq1IE3Zt6psr/IPZB7IfdE7g31ndvTpfrg6cOice4o8+4u2F+kNkuNllotNZtMFAZkaZG8Jhhj8J3W3t7VoBrX704b4u1LMQRZ/inHuFa3utW56NR3cnKcvBb7wxlsS70eOmOIuidyb6jv3s+3qz74CNvSAXKOgdRqqdlkojCwoaIFLk+32tjDqGT96tu76nHdjGQtluv01ajEMJXCX99Rp55Q6NvJk+//dtbjysmJPrFtdX/JjQ1V90TuDUcH+kb6nPQ96YPSF6lHhi1E1Wqp2dx7wERhYE1JC0IC/ZEVbdxdB+XJt6OzGz+fm+btSzGcX56YgQZHJz7ax6WGfbG8wK6OYL1jXrq3L8Vw5J7IvZF7RN9O+pz0PemD9FVSq6Vmc9TSRGFgfXmr2n7YqPMFPF3dau3qxRPifWp/7/48hGbh8Gi8k9fI2eDfQmY4L8lrUCfHDTHJltuDSe7J+aPj1D1iWzoyuT/S5+Sod184zKq/Sa1eND4eS/c0qhpOJggDGyQMGHhUQM4Ar2lz44YZKd6+FMO6cWaKOpp2Tx0PDDmS7dUOlDW7cP30ZG9fimHdMCNZ3SO5V3R4u+ucqs/J/aLD1yWZT7G5stXbl2J4Xg8DTrcHe+udyIo27hP3ysImjE6wGn4PBG86JTcaqZEWrOCuhEe0stCuRsFOGGL8Lbe9Re6N3KMVhXxV8G11Sfqc9D06NKnZUrtZl0wQBnbXOiEDOLJRhBHJRCZZ6XDJhARTHJ7kLfKKR4bkVpc0c0juMGT55drSFjXZi23p8OTeyD2Se8Ulq4cmfUz6mvQ5o75eNUxbmpCAdWWtnJRq9DDQO6ycatB38Zsr29QklAvG6Lft8NGSd732do8avqRv2l7dhlZXl5ovQN/eluReyT2jb5I+Jn3tgtFsS9/m/NGxaO/sUrWcDBwGChraERkcgAiD7sC2saJnPsOwOE7Q+TbT0iIQExqo7hl9k9yXlAgLxml0GNGxGp8chuSIIDVfh75pY3mr6mtT0/Q5jOh4DjGSGs66ZPAwIBNgZF9yo5JJTKcM5W6DfSHDlSfnRHHi12HsqHZgQa6Nrwj6QO7RgtxotqXD2F7Thvk5Nr4i6COp4WxLBg8DcrpUrNWYYaClw4PSpg7MyeRkr76amxWF/Don3/UeYpfNwsZ2zMmK9PalmMbcrEgUNrSre0cHSd/Kr2NbOhpSw6WWS00ng4aB8maXGu4yooKGnnffZjhW2Shk2NLd1Y2SpnZvX4qhyAiYzKucqtEZ88dL7pXcM7l3dJD0LeljfEXQd701vLemkwHDQE2rC1EhxpwvUGzvQEign9omlfpmTGLP3IriRp4n/vW2FOAHjOTmMH0m90rumdw7Oqi3b43l9sN9JjVcajnbkkHDgOyg1eDsRGSwMUcGKppdqhHxvVzfRQQHqolfFS0ub1+KoZQ3d6jttoMDvZ6/TUPuVaYtBBUtLOBfr0syEVXnY6+PltRwqeVy7+jQvFqZZMmeHFAUZjFmgaxtc2OIgXdGNCq5ZzWtbm9fhuHakpHP3jDy9sRsS18lu6EaeZM2I9cl6Yd0aF79Fm7p6FS/hhr0acne3omUSIu3L8OUe4LLvaODZE0429LRk3sm946+XpcYBo6tLbEuHY5Xv4Wd+3eEshg0DMjpaTGhxlzpYGQyIbSNx4Z+RavLg1irMV+HGZncM7l3dBDb0rGJZl06Iq9+C8srAhFo0HfyElaMuhmSkck9a+/k0sIvk+VxERa2paMVbgngNrJfI7vpsS4dPblnTi5TPaxAbx/nKgyaBdT+30EynZmOiiXAH51d7HRf1qnakjFHwIzMGhSgTp276o38Qf1zwy3+uPukDMSHBRmzLvmzLR1bXeJDyuFwrOmI/MAj1Y8t5HGXvW/iHTl6N89KUe1pMDexcri78IdPy9RpqkYMA35Sl9TxbnT0D5/shYYMA72vB4x6yp0lwE8dsUxHP4wZZNThHjKVMEsA7jopY1D/zKb2ThUGjLqJpoxWcrj72F7VSU2nQ/PqWFPw/mFT2U3LiKwWfzRz+8qj1tTuQWgQhzHJnA7UJY8xv3Clb0kfo6MjtVxqOh2aV+9M71+MUSebyWmKsqaXjk5tm0vdOyIzCg70U/OYZB8Uo06Ekz5GR0dquVE3uIPuYSDC0vMX4zDoco/o0CCUcvvKo1baJOdNGO9dK1FfyHwXWcXgMOgrwlipS00MA0dLarksLyQDhoHAgJ5OZ9S1n0nhQerUNDq6LablMJCkCIYBMi9biHH3N0iM6KlL0teo7+SeSU2nQ/P6C5Q4a6Bh38unRQWjpKlDbT5EfVPW5EKbqwtp3CGNTCwuLBDNBn0vL31Lgoqc+Ep9IzVcarnUdDJoGEiKsKDRacwtInv3/95S1ertSzGNzZWtB/aUJzKr5Ajjbl2bvb9vbapgXeqr3hrOMx0MHAZSIy3q5EIjkhPTZDLRmpIWb1+KaawpbVHbEcuID5FZyd7/DQ5j1iXpW/LuW/oa9Y3UcKnlUtPJoGEgMzoEdQ5jztiXfRCGxYXio31N3r4U0/io0I4R8aHcdIhMLdMWbNgT7qRvjYwPxUeFrEt9JTV8eJzVsFvfG4G/EY6VrG5xG3bjofFJYVhZaIeL+6P3abOWtaUtGJ8c5u1LITruutTU4THsSqdxSWH4oqxF9Tk6MqndUsPHJVm9fSmG5vUwkBsbojYdMmoKn5IaoSbEcXTg2727u0Ht2ib3jMjMcmND1a8VLcacpDclNVztsy99jo5MarfUcNYlg4eBEfE9aa282Zjr+YdEB6vlKK9uq/P2pRjeq9vrMDQ2xJD7uRMdjeHxoQdWxxhRQrhF9TXpc3RkUrulhkstJwOHgYyoYIRZ/FFk0M195P3cCVlReGVbLc8pOIIGhxvv5DVgblaUty+F6LhFhQQiLdKCYrtx9xmRviZ9TvoeHZrUbKndUsM5j8ngYcDf3w9jE8NQZODNfU7Osam9EDg6cHjPb6yBTPs4cQjDAPmGcclhKGo05kOKmDckCp7ubvxrU423L8WwpGZL7ZYaTgYPA2JyajgKG40bBlIiLZiUEobHPi/nrl+HIJM//7ymArMyImDjdp/kIyanhKvdNI3a52V54eyMSDyxusKwE7C9Sf7epGZL7ZYaTiYIA9PSItRe20be6e/skbHYWNGGlVzO8w1v7KhTW32eMzLW25dC1G+mpUfA3u5Bdatxh+Glz0nfkz5IXyW1Wmq21G4ySRiYmRGpft1d54BRTUwOUysffrW82LBPCt7Q1dWN+z8swYTkMAyN65l0ReQLZqT31KW8WieMSvqc9D3pg9IXqYfUaKnVUrOldpNJwkDu/hnoO2qMGwZk8snF4+OxqrgZS7ic54B/b65Rf29yb4h8SVxYkNpAa6eB65KQvid9UPoi9ZAaLbX6kvHxnDhopjAgf1knZUdhW5XD8O8QZROi25YUooObEKGloxN3vF+E2ZmRB5aIEvkSmRC7rboNRiZ9T/qg9EXpk7qT2iw1Wmr1pJRwb1+OaRgiDIgFuTbk1zsNPW9AQsvVUxLVZMeHPimD7u5dXowGpxtXTErw9qUQDYgFudHqdMCaVmPuN9BL+qD0RemTupPaLDVaajVHBUwYBk4bGq2Wpm2uMnYKl7MUzh0Zi9+sLME2g1/rQPq8uBmPfVaBRePikRjOmbrkm+bn2BDgBzURzcikD0pflD4pfVNXUpMfWFGiarTUajJhGMiwhWB0ghXryox/Etei8fHqiNOL/5un5UZEsh/6Ja/kqfepXEFAvkyWys7KjMS6cuPXJemL0ielb+p4ZoHUYqnJsoxQajSZNAyIc0bFYkN5q9pz28gsAf64bU4q9tQ5cdPiAug2S/fK1/egttWNW2enIoCngJGPky/ZLZVtcLqNPU9I+qL0Semb0kd1W/UktVhq8k/npKoaTUfHUHfsgtFxarcoMwy/y6lm105LxrPrq/GXNRXQxW9WluKNHfW4ZVYKkiL4eoB83/mj4+DydGO9CUYHpE9K35Q++tuVpdCF1GCpxVKTs/h6wPxhYGJKGLKjQ/BpkTneecmkx++MiMHNiwuwJM/3lxu+uLlGTVCSpUwz9u8NQeTrhsSEqFMCzVKXpG/K/IF7lherPuvr3smrV6MCUoulJpMPhAGZ+XnJhHisLm02zdK9KycnYmpaBC56aRc+LrTDVy3eVY8rXtuD+TlR+N7YOG9fDtGgumRCgnqF2WLg1U5f9v1xcaqvSp+VL0tfJTX3uy/lqV1spRaTj4QB8YOJCers6bWlxh+S631P97O5qerI0zOf34GPfDAQvL2rHhe+tAvT0sJx44wULtch7ciTdld3Nz4tMsd25NJHpa9Kn73gxV2qD/saqbULn9+haq/UYM5f8rEwMCyuZwONDwrM86Uqk1XuOjEdw+JCcfo/tuPNnb6zT/jzG6tx/r93YkpqBH42N40djrSUGGHBwuEx+GCv3TQT83oeVNJU35U+LH3ZV/xvR52qtcPjQlXt5YTB42fIO/jjaUlq9m5Fs3GPD/264EB/3H1SOqakScfbhYc/LTNN0TgU2ef8ng+K9r8asOHnc1MRyCBAGvvxtGQUNLQjv964J6x+nfRZ6bvSh6UvS5828xkGUlOltspoh9RaqblSe+n4GfIuXjQmHjGhgViyuxFmEhTgrzreBWNi8fN392HRy3loNuF633qHG2f9a4eajXz5xATcMCOZIwKkvdOHRSPTFmy6s0mk70oflr4sfVr6tvRxs5FaKjVVaquqsXNTVc2l/mHIOxkS5I9rpyfjwwI7HC5zTNjp5e/nh8smJuL2E9KwOK8BE57YiM+KzfGeUSzLb8TYxzaqXczuPTkDF4yJ4xwBov1fqjfNTFGrChpM9mUqfVj6svRp6dvSx6Wvm4XUUKmlUlOltkqNlVpLPh4GhCRZt6cb75uowX7ZnMxIPHpmNkIC/TH3b1vV8kMj7wpW1+bGD1/bjdP+sR2J4UH401nZmJzKQz6IvuyqKUmqT79jstGBXtKnpW9LH5e+Ln1e+r5RSc2U2ik1VO671FSpraRRGEiJDFYrC97Oa4DLY45lhl8nWxY/eGqWWvLyzLoqDH1kPZ7+ohKdHuO8s5MlnH/6rBxDH1mH17bX4/rpybh/fgZirUHevjQiQ25PfO30JLy7uxGtJhu17CV9W/q49HXp89L3pQYYaTm329OlaqXUTKmdUkOllkpNJc3CgLhjXhoanZ1Yvtc8KwsONbQo2yw/eXYORida8eM392L4o+vx3Poqr3Y+ef3y5OoK5D68Dj9dWojp6RH4y9k56r0oXwsQHd5ts9PUlunvmHijMenj0telz0vflxogtUBqgjdfzUpNlNo44tENqlZKzZTaKTWU85YGViAMTJYZyvreV7fXqdmwZp41GhcWhNtmp6rTtF7eWour3sjHL5cVqRnKknoH64St/DonnllfpdK2vb1TDbn98sR0pEUFD8qfT2R2yZEW1W+f21CNs0bEINwSADOPdNwwI0WdvyB16eZ3CtQuo1dPTcLVU5IwNC50UK6jqLEd/9hQjb99UYnqVjdmpEfg5pkpyI7h1sKDxa/b4Ovf9tY7MeKP63HZpEScN8p3TsgrbepQk2E+3tekDkCRL+WLxsap4pId038dUP56d9c61TvOV7fV4ouyVlW8Ts6OUn8WzxcYHLKsSw6RufvkDG9fCvWDqhYXsv+wTvWhSycmwJc+l4x4rChsUq9BZNOii8bG46zhMWpzn/4cNSxscKo/69VtdVhV3IzQIH/MGxKFs0fEaPdwsqO6DXcuK8bu2yarh2BvMHwYENe9mY8Xt9Tir+fkIiLYvCn8UCQIrC5pxqfFzWpvBRl+zLIF44QhUWr4bnxyGEbEW9VSy2/riPJXWdvmxq4aB7ZUtaldHD/Z14SyZhcsAX6YlBKOuVmRautOM4+ymBHDgO+5a1kRHllVhqfOzlUjf75Ehuu/KGtRKyc2VrSqg5rSIi0H61JSGEYmWBEfFtSnutTg7ERerUPVuN66VGTvUPsgSI2bmxmJmRmRKhDoaAfDQN/Tau4j6zA/26aGr3yVvKvbWtWGrVUO5NU5UNTYceA4Z3mal3O646yBiAoJPLDjlnTapo5ONSO4otmFtv3HrMqXv5ysKOebS2cbkxCmlmySdzAM+B6Z6S7v2ccmham/W1/V7u7C9po29UWeV+vEvsZ2FQ5EWJB/T10KC0JUcOCBhwyZ9C33p87RqepS72RL+fLPig7GiDgrxiXJTxisJn7N4kthwNBzBnrJUPZdJ2bgnuVFOHVoNDJsvjmEJJ1CThzrPRFQZtTKU315sws1rS40ODrR4vKoSZW9IUE6lzXIH6MSrJiTFYXEsCCkRVnUagzuGEg0cCSU//bULDXR7Yxh0WoEzxfJQ4RsaSw/QmqP7A5b1uRCdZtb7bkgBzjJHKQv1yV5yh8RF4pZGRFICLcgNdKiRhe4UZAxmSIMiNvmpOLZ9VVqgslvTsnUYsa7dBp5upcfIjLmvgNSk/72RRUePmOIFjPe5Ys+wxaifsh3mCaiyfDTU+fkYlu1Q01uISLyNvny/+u5Q1HY0K4mBBOZlWnCgDhlaDQuGR+vlvTIUDkRkbdNTYvAjTNT8NKWWlS2uLx9OUS+HwbEn87KUdtSPrW20tSnAhKR75Dd8WSL3ydWV6CLdYlMyHRhQGat/u3cXKwpbcHyAvPuTEhEviM8OAD/vHAYtlc78NbOem9fDpHvhwFx3ug4XDEpAc+sq1azWomIvO3EbBt+OicVL2yuRUG909uXQ+T7YUA88Z1cpEZZ8IdPy017kBER+RZZajg20YqHV5Wb7vh10pu/mYflXl00EmVNHXj6iypvXw4RkVr19MrFI9HU7sETaziviczDtGFATEgJx5Pn5GLZXjuW5Td6+3KIiJAbG4rnLxyGz4qb8QbnD5BJmDoM9G76ce20JPz1iyrsrHF4+3KIiHD+mDh1Gui/NtZgfXmLty+HyPfDgHjsrBy15eXvPi7lOl8iMoQHFmSqUw1lXpPs509kZD4RBiyB/njjB6PUCVq/XlGiDsggIvImf38/vPS9ERgeF4oHVpSoE0WJjMonwoCItQbhvSvGqNO0HlhZCoebM3mJyPsTnZdcPhrWoADc/2EJmjv4oELG5DNhQOTEhqpAIEdmPvhRmTrel4jIm+QE0WVXjlEPKL9eUcolh2RIPhUGxKTUcCy9fDT21jvxu4/LuAcBEXnd8Hgrll05FtWtLty/ooQjl2Q4PhcGxNwhUVh82WjsrGnjCAERGcLElHAs++FYlDW71CuDNo4QkIH4ZBgQJ+fYsPTyMcirdahJhRyaIyJvm5YegQ+vGouKFhfuXV6MZk52JoPw2TAgTsqxqXd1xfYO3L28mMceE5Ehjjz++JpxsLd7cMeyItS0cjk0eZ9PhwExOzMKn/xoHFo7PPjFe/vU9sVERN40Pjkcn/14PAL9/XD7e0U82Ii8zufDQG/HW3PdBESHBqqOt7my1duXRESaGxoXijXXTkB2TAjuXFaMNSXN3r4k0pgWYUBkRodg9XUTMCszQk3eeXtXPQ8RISKvSoywqFcGZw6PxoMfl+HlrbXoYl0iL9AmDIiokEAsuWwMfjI7Fc+sr8Yjq8rhdHOlARF5j9USgFcWjcSvF2TiP1tq8duVpWjp4IRnGlxahQERGOCHhxdm47/fH4ENFa346dJCFDZw33Ai8u7WxfecnKF2K9zb0I5blxRiFw9eo0GkXRjo9d1x8dh440S1jfHP392H/+2s5/AcEXnVGcNjsPmmieoY5DuXFeGlLTXo7GJdooGnbRgQw+KsWHv9BNw8KwX/3FCNu5YVq62MiYi8JcMWouYR3HtyBl7dVqdWQRXz1EMaYFqHAREc6K9eG6y4eiza3B7c/E4BXt9RxzRORF59nfmr+Zlq0nOAvx9uXboPL26u4fbqNGC0DwO9Tsy2Yfstk3HDjBS8sKkGty0pxPbqNm9fFhFpvkHRphsn4c55aXhjRz1uXlyIDeVcGk39j2HgS8IsAfjjmdlYd/1EJIQH4ZfLivHQJ2WoauGrg76STZ1+uaxIja4Q0fELCfLHr0/JUnMJhsWFqoOOHlhZwg3UjkLV/u2f5UGPDo1h4DAnH66+dgL+eeEwFDS044a3C/DMuirYuZ3xYdW1ufHn1RW4aXEBtlc78PxGdjqi/jQqMUy9znx10QjUtLpVX3tyTYXqe3RoUrOldksN31zZhle38yHlcAIP+280J0t9Lp+UiAvHxOHRVeV46NMyfLDXjjOGR+PckbGwhfLWCSlEMny5bG8jwi0B+MMZ2Shr7sB/tjAMEPU3Pz8/XDg2HmeNiMVTayvVCMHKwiacmhuN80fHIi4syNuXaAhyDs1bu+rx7u5GNf9CJmPKajGp43Ro/Ebrw6uDu0/OwHUzkvHIp+V4fHU5luxuwPwcG84ZGYvkCAt0VGLvwJs76/HRviaEW/xx90kZuGVWCiJDAnHXsiJvXx6Rz786uHVOKq6akojHPq/AH1eV4b38Rpw4JArnjopFhi0YOpLVYG/n1WP5XjuCAvzUBnM/m5uKGGsQHmEQOCKGgT6S/QgePC1LNSwZDn98dYVKnTLBZ+HwaExIDoO/nx98maerG+vLW7F0dwM2VbapIPTgqVm4dnoSIoLZlIgGm4Rv2azoJ7NT8Ne1VXj0s3IsL7BjYnIYFg6PwZTUcLUawZfJE7+8Ali6uxHryloQYw3EXSem48aZKSoEUN+wgh8laVz3zs/Ez09Iw4uba/H45+W478MSJIUH4eQcG07KjkJiuG+NFpQ3d2BlQRNWFNpR5+jE1LRwvHDRcHx3bBwsgZx2QuRtEsalJsno3Cvb6tQI5m8/KkWcNRAnZ9twUk4UUiN9a7SgutWlXpGsKLCjqtWNsYlWPH3eUFwyIR6hQQHevjzTYRg4RtLYrp6apIbpVpe04Jn1VXhlay1e2lKLUQlWzMmMxMyMCDWiYNaO9nlJCz4rbsaeOiciggNwyfh4XDM1WU2wJCLjkXD+g4kJ6mdDeYuaPPfillq8sr1OrUSYnRmJWRkRpn1gqXe4Vb1dVdyMnTUOhAX5q91kr56SpOqtzKmgY8MwcJyk8c2SDpYZicfPylHv0WUL0X9sqMbT66owNDYUk1PDMCklXP1now7ZySZLu2sd2FjRps5skPMaggP8cPqwaDywIBPfGRnDtE1kIpNTI9SPLJdevKtB1aWXNvfUJjk2eXJKOCalhGF4vBWBBq1L8moyv96JjRWt2FDepv5zkL8fFuTacOe8dDU/IjyYdak/MAz0I2mUvam80enGkrxGLM6rx7t7GvHy1jqEWfzVqMGoeCuGx4ciNyZUTQTyBofbg/y6duyuc2BnjVMdiuLs7EJMaKBaMfG7U7PUr5wLQGRuEuLl6Vl+Wjo61VwnmWQnv8pSu9BAf4yUupQQiuFxVgyNC4HVS8G/3d2FvQ1O7K51Ymet1CYH2lxdiAoJwGlDo9WqgDNHRCM61JwjrkbGSj9ApLH2BoNOTzfWlbfgw712Nfv+tR11qoFLGE+PClYzfzNtwUiLDFaT8hIjgvqlM3Z3d6PN3YXqFhcqW1woa3ah2N6BYns7yptckA2XI4MDMDMjEhfNz8CCHBsmpvj+hCMiXUm47w0G8tS9qaJVTTj8qLAJb+1qQEtHLaT3p0ZZkGkL2V+XLPvrkkUtH+6vh5HqFvf+uiQ1qUOtUCpt6oDsBC8PTjPSI3HHCemYn2vD1NQItUSQBg7DwCCQRixfuPJztwzJe7qxo6ZNzczfWN6KLVVteCevAfb2g2eYy3I9maxoCwlQHVB+QoP8ERzgr36/3u9r6Tjy+7V3dqkn+zaXR52FLr+XvF9zuA/uZR5rDcToBCvOGxWnXlvIRMAR8dYB+fKXa5BDVqiH/N0QGYn0+ylpEernjnnpKhzk1TqwrqxVDctvqWzF+/mNqHcc3GzNGuSv5kFJXZJ5RLL0WkYWQgIPXZc6PF1wurvQ6vKoH6lLDQ43Wl0H+4P8XqMTw3Dm8Bg1H0lWQIxOCBuQL39XZ7ch61J1q/d3ufXrlsdH8jr5a5ANfGTHw32N7SolS2qubnWjts2NpvZONLV70N7pQUdnNzzd3SrBS4eWgCCvG+QpPzo0EHHWIDW6kBLRM+og7wflZ7AmM64ssOP7L+epa6Qe8p7z9UtGqbklRGYiDxUyh0h+pC5VtHSop/o6h1tt7tPc4VHD+/LFL4FCen2Anx+CA/0QEhighvijQgIRHxaExPAgNcogdWlIdAhyYkLURkmDMfFvfVkLznlhp7pOIxoaG4oPrhzrtTkQDANERESa4yJxIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIg0xzBARESkOYYBIiIizTEMEBERaY5hgIiISHMMA0RERJpjGCAiItIcwwAREZHmGAaIiIigt/8HQcrN2J0BLwoAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -252,18 +243,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Adding top_level\n",
-      "Adding aepFLORIS\n",
-      "Adding collection\n",
-      "Adding spacing_constraint\n",
-      "Adding boundary\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mturbine_type has been changed without specifying a new reference_wind_height. reference_wind_height remains 90.00 m. Consider calling `FlorisModel.assign_hub_height_to_ref_height` to update the reference wind height to the turbine hub height.\u001b[0m\n"
+      "Running OpenMDAO util to clean the output directories...\n",
+      "\tFound 1 OpenMDAO output directories:\n",
+      "\tRemoved case_files/ard_problem_out\n",
+      "\tRemoved 1 OpenMDAO output directories.\n",
+      "... done.\n",
+      "\n",
+      "Created top-level OpenMDAO problem: top_level.\n",
+      "Adding top_level.\n",
+      "\tAdding aepFLORIS.\n",
+      "\tAdding collection.\n",
+      "\tAdding spacing_constraint.\n",
+      "\tAdding boundary.\n",
+      "System top_level built.\n",
+      "System top_level set up.\n"
      ]
     }
    ],
@@ -276,7 +269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "5a06920a",
    "metadata": {},
    "outputs": [
@@ -286,28 +279,528 @@
      "text": [
       "/Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/openmdao/core/group.py:368: PromotionWarning:<model> <class Group>: Setting input defaults for input 'x_turbines' which override previously set defaults for ['auto', 'prom', 'units'].\n",
       "/Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/openmdao/core/group.py:368: PromotionWarning:<model> <class Group>: Setting input defaults for input 'y_turbines' which override previously set defaults for ['auto', 'prom', 'units'].\n",
-      "/Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/openmdao/recorders/sqlite_recorder.py:231: UserWarning:The existing case recorder file, /Users/cfrontin/codes/Ard/assets/logomaker/problem_out/opt_results.sql, is being overwritten.\n",
       "/Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/openmdao/core/driver.py:700: DriverWarning:The following design variable initial conditions are out of their specified bounds:\n",
       "  x_turbines\n",
-      "    val: [-2500000. -1250000.        0.  1250000.  2500000. -2500000. -1250000.\n",
-      "        0.  1250000.  2500000.]\n",
+      "    val: [-2500. -1250.     0.  1250.  2500. -2500. -1250.     0.  1250.  2500.\n",
+      " -2500. -1250.     0.  1250.  2500. -2500. -1250.     0.  1250.  2500.\n",
+      " -2500. -1250.     0.  1250.  2500.]\n",
       "    lower: 0.0\n",
       "    upper: 3000.0\n",
       "  y_turbines\n",
-      "    val: [-2500000. -2500000. -2500000. -2500000. -2500000. -1250000. -1250000.\n",
-      " -1250000. -1250000. -1250000.]\n",
+      "    val: [-2500. -2500. -2500. -2500. -2500. -1250. -1250. -1250. -1250. -1250.\n",
+      "     0.     0.     0.     0.     0.  1250.  1250.  1250.  1250.  1250.\n",
+      "  2500.  2500.  2500.  2500.  2500.]\n",
       "    lower: 0.0\n",
       "    upper: 1250.0\n",
       "Set the initial value of the design variable to a valid value or set the driver option['invalid_desvar_behavior'] to 'ignore'.\n",
-      "RuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:328\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:163\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_velocity/gauss.py:80\n",
-      "invalid value encountered in divideRuntimeWarning: /Users/cfrontin/miniforge3/envs/ard-dev-env/lib/python3.12/site-packages/floris/core/wake_deflection/gauss.py:498\n",
-      "invalid value encountered in divide"
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mSome velocities at the rotor are negative.\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Return from COBYLA because the objective function has been evaluated MAXFUN times.\n",
+      "Number of function values = 200   Least value of F = -308484548668.90735   Constraint violation = 0.0\n",
+      "The corresponding X is:\n",
+      "[3.82878819e+02 4.16632722e+02 3.87355300e+02 3.85898926e+02\n",
+      " 2.54458435e+03 3.28097905e+02 3.72969889e+02 1.52171917e+02\n",
+      " 1.18732891e+03 2.30254481e+03 2.50614107e+02 3.49670342e+01\n",
+      " 4.70980344e+01 1.18730026e+03 2.49024865e+03 1.49610537e+01\n",
+      " 5.78436918e+01 2.48283056e+02 1.18745011e+03 2.65248265e+03\n",
+      " 1.24293516e+02 2.52216306e+02 4.44797655e+02 1.97392672e+03\n",
+      " 2.08361820e+03 1.41958509e+01 7.20367204e+00 4.08185104e+01\n",
+      " 4.70596956e+01 2.97538062e+01 3.05509359e+01 1.64848200e+01\n",
+      " 1.40816082e+02 3.26515553e+01 6.72008119e+00 6.78064630e+01\n",
+      " 3.59223571e+02 2.88491575e+02 2.06179683e+00 5.54892893e+01\n",
+      " 6.21332573e+02 4.90069901e+02 9.31886966e+02 9.95893556e+02\n",
+      " 1.24960495e+03 8.29886278e+02 9.34262660e+02 9.27168724e+02\n",
+      " 7.98492623e+02 9.05072172e+02]\n",
+      "The constraint value is:\n",
+      "[-3.82878819e+02 -4.16632722e+02 -3.87355300e+02 -3.85898926e+02\n",
+      " -2.54458435e+03 -3.28097905e+02 -3.72969889e+02 -1.52171917e+02\n",
+      " -1.18732891e+03 -2.30254481e+03 -2.50614107e+02 -3.49670342e+01\n",
+      " -4.70980344e+01 -1.18730026e+03 -2.49024865e+03 -1.49610537e+01\n",
+      " -5.78436918e+01 -2.48283056e+02 -1.18745011e+03 -2.65248265e+03\n",
+      " -1.24293516e+02 -2.52216306e+02 -4.44797655e+02 -1.97392672e+03\n",
+      " -2.08361820e+03 -1.41958509e+01 -7.20367204e+00 -4.08185104e+01\n",
+      " -4.70596956e+01 -2.97538062e+01 -3.05509359e+01 -1.64848200e+01\n",
+      " -1.40816082e+02 -3.26515553e+01 -6.72008119e+00 -6.78064630e+01\n",
+      " -3.59223571e+02 -2.88491575e+02 -2.06179683e+00 -5.54892893e+01\n",
+      " -6.21332573e+02 -4.90069901e+02 -9.31886966e+02 -9.95893556e+02\n",
+      " -1.24960495e+03 -8.29886278e+02 -9.34262660e+02 -9.27168724e+02\n",
+      " -7.98492623e+02 -9.05072172e+02 -2.61712118e+03 -2.58336728e+03\n",
+      " -2.61264470e+03 -2.61410107e+03 -4.55415650e+02 -2.67190209e+03\n",
+      " -2.62703011e+03 -2.84782808e+03 -1.81267109e+03 -6.97455192e+02\n",
+      " -2.74938589e+03 -2.96503297e+03 -2.95290197e+03 -1.81269974e+03\n",
+      " -5.09751351e+02 -2.98503895e+03 -2.94215631e+03 -2.75171694e+03\n",
+      " -1.81254989e+03 -3.47517351e+02 -2.87570648e+03 -2.74778369e+03\n",
+      " -2.55520234e+03 -1.02607328e+03 -9.16381798e+02 -1.23580415e+03\n",
+      " -1.24279633e+03 -1.20918149e+03 -1.20294030e+03 -1.22024619e+03\n",
+      " -1.21944906e+03 -1.23351518e+03 -1.10918392e+03 -1.21734844e+03\n",
+      " -1.24327992e+03 -1.18219354e+03 -8.90776429e+02 -9.61508425e+02\n",
+      " -1.24793820e+03 -1.19451071e+03 -6.28667427e+02 -7.59930099e+02\n",
+      " -3.18113034e+02 -2.54106444e+02 -3.95047193e-01 -4.20113722e+02\n",
+      " -3.15737340e+02 -3.22831276e+02 -4.51507377e+02 -3.44927828e+02\n",
+      " -3.44691408e+01 -2.69950104e+01 -3.30009472e+01 -2.16176014e+03\n",
+      " -5.71688723e+01 -1.01684948e+01 -2.63168450e+02 -8.04660395e+02\n",
+      " -1.91967917e+03 -1.42715307e+02 -4.89985091e+02 -4.33573161e+02\n",
+      " -8.04511573e+02 -2.10777298e+03 -7.09913042e+02 -5.76283228e+02\n",
+      " -9.27507655e+02 -1.26927611e+03 -2.58405303e+03 -8.55695551e+02\n",
+      " -9.29297083e+02 -9.15068790e+02 -1.77385173e+03 -1.91994005e+03\n",
+      " -4.45758020e+01 -5.03282254e+01 -2.12806973e+03 -9.15601251e+01\n",
+      " -4.46369785e+01 -2.96295423e+02 -7.71114836e+02 -1.88591077e+03\n",
+      " -1.76732545e+02 -5.19216022e+02 -4.64410908e+02 -7.70683312e+02\n",
+      " -2.07417666e+03 -7.33820425e+02 -6.01571032e+02 -9.39882024e+02\n",
+      " -1.25366011e+03 -2.55784652e+03 -8.73078735e+02 -9.41524580e+02\n",
+      " -9.20394713e+02 -1.74679649e+03 -1.89341047e+03 -6.40747840e+00\n",
+      " -2.15725605e+03 -6.01389756e+01 -2.82664243e+01 -2.55558280e+02\n",
+      " -8.00013924e+02 -1.91549166e+03 -1.39377616e+02 -4.74929432e+02\n",
+      " -4.20851274e+02 -8.00881897e+02 -2.10294315e+03 -6.89689897e+02\n",
+      " -5.57138383e+02 -9.01854534e+02 -1.24591999e+03 -2.56748116e+03\n",
+      " -8.31761477e+02 -9.03605284e+02 -8.88208242e+02 -1.75820195e+03\n",
+      " -1.90374289e+03 -2.15875342e+03 -6.01109955e+01 -3.31947538e+01\n",
+      " -2.51829073e+02 -8.01558114e+02 -1.91706897e+03 -1.36865021e+02\n",
+      " -4.69678811e+02 -4.16021937e+02 -8.02662254e+02 -2.10436523e+03\n",
+      " -6.83653686e+02 -5.51250181e+02 -8.95463546e+02 -1.24208155e+03\n",
+      " -2.56583511e+03 -8.25380262e+02 -8.97216626e+02 -8.82076263e+02\n",
+      " -1.75683775e+03 -1.90221737e+03 -2.21648521e+03 -2.17165362e+03\n",
+      " -2.39498758e+03 -1.35725716e+03 -2.43131699e+02 -2.29428446e+03\n",
+      " -2.53115042e+03 -2.51085169e+03 -1.35756518e+03 -6.01208622e+01\n",
+      " -2.59787458e+03 -2.52898459e+03 -2.46715161e+03 -1.66590360e+03\n",
+      " -1.22461238e+03 -2.54911998e+03 -2.46436214e+03 -2.28351733e+03\n",
+      " -9.57395877e+02 -9.89277164e+02 -4.70236229e+01 -2.07624142e+02\n",
+      " -8.59232199e+02 -1.97458934e+03 -8.59736975e+01 -4.40397771e+02\n",
+      " -3.81435775e+02 -8.59673162e+02 -2.16229318e+03 -6.68637264e+02\n",
+      " -5.33098069e+02 -9.04861625e+02 -1.29242757e+03 -2.62466187e+03\n",
+      " -8.24906630e+02 -9.06890513e+02 -9.04179076e+02 -1.81617233e+03\n",
+      " -1.96128364e+03 -2.53395560e+02 -8.14518103e+02 -1.92959825e+03\n",
+      " -1.32681887e+02 -4.81367278e+02 -4.24474936e+02 -8.14456708e+02\n",
+      " -2.11763662e+03 -7.02857878e+02 -5.68846010e+02 -9.23853535e+02\n",
+      " -1.27381945e+03 -2.59167061e+03 -8.50564242e+02 -9.25686256e+02\n",
+      " -9.13510748e+02 -1.78173906e+03 -1.92766694e+03 -1.04079138e+03\n",
+      " -2.15454853e+03 -1.22559912e+02 -2.47867170e+02 -1.81240374e+02\n",
+      " -1.04438525e+03 -2.33963181e+03 -4.99721467e+02 -3.61766566e+02\n",
+      " -7.96886631e+02 -1.34274149e+03 -2.73513418e+03 -6.89632542e+02\n",
+      " -7.99727548e+02 -8.39033963e+02 -1.93683341e+03 -2.07715344e+03\n",
+      " -1.11551596e+03 -9.37372879e+02 -1.19774116e+03 -1.16857920e+03\n",
+      " -3.05883958e+01 -1.30311850e+03 -1.31186437e+03 -1.21859142e+03\n",
+      " -1.30016455e+03 -9.63240632e+02 -1.90463797e+03 -1.32876777e+03\n",
+      " -1.29897444e+03 -1.16254481e+03 -1.09783680e+03 -1.25077927e+03\n",
+      " -2.05283840e+03 -2.29481183e+03 -2.27297802e+03 -1.11525290e+03\n",
+      " -1.93934612e+02 -2.36870881e+03 -2.29614978e+03 -2.25298001e+03\n",
+      " -1.49060265e+03 -1.29120709e+03 -2.32859934e+03 -2.25037242e+03\n",
+      " -2.07326903e+03 -8.57257982e+02 -9.24641981e+02 -3.62528058e+02\n",
+      " -3.00199740e+02 -9.38989201e+02 -2.23966704e+03 -6.01599419e+02\n",
+      " -4.64182686e+02 -8.64082272e+02 -1.31871290e+03 -2.67686623e+03\n",
+      " -7.72476802e+02 -8.66456302e+02 -8.81026856e+02 -1.87181823e+03\n",
+      " -2.01517055e+03 -7.17633542e+01 -1.20641331e+03 -2.47399586e+03\n",
+      " -2.62870015e+02 -1.32829733e+02 -6.11101798e+02 -1.31664812e+03\n",
+      " -2.76480730e+03 -4.79062924e+02 -6.14707661e+02 -7.00371977e+02\n",
+      " -1.98809368e+03 -2.12012181e+03 -1.17562744e+03 -2.45423476e+03\n",
+      " -3.34387493e+02 -2.01863159e+02 -6.74115115e+02 -1.34194512e+03\n",
+      " -2.77700563e+03 -5.46869146e+02 -6.77563234e+02 -7.52377179e+02\n",
+      " -1.99317946e+03 -2.12781112e+03 -1.30404196e+03 -1.32584760e+03\n",
+      " -1.23037419e+03 -1.32148572e+03 -9.93830394e+02 -1.92434874e+03\n",
+      " -1.34732067e+03 -1.32036995e+03 -1.18622497e+03 -1.11941064e+03\n",
+      " -1.27232468e+03 -2.53913771e+03 -2.47092035e+03 -2.40717178e+03\n",
+      " -1.60674821e+03 -1.20508455e+03 -2.48946330e+03 -2.40437617e+03\n",
+      " -2.22344073e+03 -9.04787157e+02 -9.41879399e+02 -1.38088486e+02\n",
+      " -3.88435476e+02 -1.23086275e+03 -2.71131682e+03 -2.35473113e+02\n",
+      " -3.92701175e+02 -5.27535594e+02 -1.96695876e+03 -2.08802414e+03\n",
+      " -4.81111366e+02 -1.23768526e+03 -2.70352314e+03 -3.46251060e+02\n",
+      " -4.84857284e+02 -5.83769770e+02 -1.94074558e+03 -2.06784515e+03\n",
+      " -9.41344252e+02 -2.42510077e+03 -1.60552497e+02 -4.59366229e+00\n",
+      " -1.96569857e+02 -1.73079038e+03 -1.83552965e+03 -1.48683749e+03\n",
+      " -1.07603782e+03 -9.37260928e+02 -7.45824183e+02 -8.10870126e+02\n",
+      " -9.00757072e+02 -2.56279086e+03 -2.42089087e+03 -2.23110556e+03\n",
+      " -8.14824056e+02 -6.65062227e+02 -1.65100620e+02 -3.34941570e+02\n",
+      " -1.84989823e+03 -1.96076535e+03 -1.92710585e+02 -1.72705399e+03\n",
+      " -1.83163314e+03 -1.53453218e+03 -1.63896813e+03 -1.52941168e+02\n",
+      " -2.73514389e-01 -1.88052071e-01 -2.71901410e+01 -3.28961574e+01\n",
+      " -1.07689469e-01 -5.32815373e-02 -6.22851595e-02 -1.19808218e-03\n",
+      " -1.71142579e-01 -1.41464656e+00 -1.00308238e+00 -1.41131921e+01\n",
+      " -1.34689973e-01 -1.99707032e-01 -4.07835038e+01 -8.76688166e-04\n",
+      " -5.77170506e+01 -9.73965350e-02 -4.99267578e-02 -3.95019531e-01\n",
+      " -1.27697035e-02 -1.86313813e-02 -6.92691766e+01 -3.02372994e-02\n",
+      " -1.00114591e+00]\n",
+      "\n",
+      "Optimization FAILED.\n",
+      "Return from COBYLA because the objective function has been evaluated MAXFUN times.\n",
+      "-----------------------------------\n"
      ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Problem: ard_problem\n",
+       "Driver:  ScipyOptimizeDriver\n",
+       "  success     : False\n",
+       "  iterations  : 201\n",
+       "  runtime     : 1.0673E+02 s\n",
+       "  model_evals : 202\n",
+       "  model_time  : 1.0540E+02 s\n",
+       "  deriv_evals : 0\n",
+       "  deriv_time  : 0.0000E+00 s\n",
+       "  exit_status : FAIL"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -316,24 +809,45 @@
     "    val=input_dict[\"modeling_options\"][\"windIO_plant\"][\"wind_farm\"][\"layouts\"][\n",
     "        \"coordinates\"\n",
     "    ][\"x\"],\n",
-    "    units=\"km\",\n",
+    "    units=\"m\",\n",
     ")\n",
     "ardprob.model.set_input_defaults(\n",
     "    \"y_turbines\",\n",
     "    val=input_dict[\"modeling_options\"][\"windIO_plant\"][\"wind_farm\"][\"layouts\"][\n",
     "        \"coordinates\"\n",
     "    ][\"y\"],\n",
-    "    units=\"km\",\n",
+    "    units=\"m\",\n",
     ")\n",
     "ardprob.run_driver()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "fa1e7a79",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plot_layout(ardprob, input_dict=input_dict, include_cable_routing=True)"
    ]

From 0355db7cb6b0ab0c1aac4df219ce3a8743490244 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Fri, 16 Jan 2026 13:05:15 -0700
Subject: [PATCH 10/30] WISDEM update and configurations (#172)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* update for WISDEM/ORBIT pyrite standard value changes

* fix typo

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 pyproject.toml                                  |   4 ++--
 test/ard/system/api/test_interface.py           |   8 ++++----
 .../unit/cost/test_orbit_wrap_baseline_farm.npz | Bin 542 -> 542 bytes
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 33961d07..024e5919 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -26,7 +26,7 @@ authors = [
 ]
 description = "A package for multidisciplinary and/or multifidelity wind farm design"
 readme= "README.md"
-requires-python = ">=3.10, <3.13"
+requires-python = ">=3.10"
 classifiers = [
   "Development Status :: 4 - Beta",
   "License :: OSI Approved :: Apache Software License",
@@ -40,7 +40,7 @@ classifiers = [
 dependencies = [
   "numpy",
   "floris>=4.3",
-  "wisdem>=3.21",
+  "wisdem>=4.0.5",
   "NLopt",
   "marmot-agents",
   "openmdao",
diff --git a/test/ard/system/api/test_interface.py b/test/ard/system/api/test_interface.py
index 94fc18e2..6a9355fe 100644
--- a/test/ard/system/api/test_interface.py
+++ b/test/ard/system/api/test_interface.py
@@ -83,7 +83,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("BOS capex (orbit.total_capex_kW)"):
             assert self.prob.get_val("orbit.total_capex_kW", units="MUSD/GW")[
                 0
-            ] == pytest.approx(2307.6532360162337)
+            ] == pytest.approx(2319.207303980254)
         with subtests.test("opex.opex"):
             assert self.prob.get_val("opex.opex", units="MUSD/yr")[0] == pytest.approx(
                 60.5
@@ -91,7 +91,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(98.96155822224087)
+            ] == pytest.approx(99.18265668471714)
 
 
 class TestSetUpArdModelOffshoreFloating:
@@ -128,7 +128,7 @@ def test_offshore_floating_default_system(self, subtests):
         with subtests.test("BOS capex (orbit.total_capex_kW)"):
             assert self.prob.get_val("orbit.total_capex_kW", units="MUSD/GW")[
                 0
-            ] == pytest.approx(2692.512849)
+            ] == pytest.approx(2704.0669170003234)
         with subtests.test("opex.opex"):
             assert self.prob.get_val("opex.opex", units="MUSD/yr")[0] == pytest.approx(
                 60.5
@@ -136,4 +136,4 @@ def test_offshore_floating_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(106.32622571190157)
+            ] == pytest.approx(106.54732417437786)
diff --git a/test/ard/unit/cost/test_orbit_wrap_baseline_farm.npz b/test/ard/unit/cost/test_orbit_wrap_baseline_farm.npz
index 272c81639a00261489f5be2e869347dd1db6ce26..f6d319226ccc3926c8898acd36c77484598922f4 100644
GIT binary patch
delta 98
zcmbQoGLJ<lz?+#xmjMD484^!KFP$i~R%+oT9VI)vvyP~;*_nDp6K}4UaeQ~J=9A5I
ZhX8LzCS7J!-IJFvnzMiuPQK4*4*;<)8X^Dy

delta 98
zcmbQoGLJ<lz?+#xmjMD48CtnI*(VCEmAa>1(|L&ZtRt$dw|H{Y#GC77`hq9ev@1_{
Y2=HcP(q%@~J$VVEISWYP<ok^F05wn+r~m)}


From c9690f33422a65a81ed25087832b7abd2169216c Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 20 Jan 2026 06:56:54 -0700
Subject: [PATCH 11/30] Add domain exclusion zones via windIO (#167)

* bring in the exclusions and their viz implications

* added exclusion code

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* new gold standard test, weird failure

* fixed value of the exclusion distance; still failing now on two: mysterious sign flip, sometimes...

* add a boundary test case that lights up the strange error

* rename and add some tests

* added exclusion test even though it's in tatters

* debugging

* use switch instead of pad to fix boundary in/out identification. also clean up debug statements

* black reformat

* black reformat

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>
---
 ard/layout/exclusions.py                     | 128 ++++
 ard/utils/geometry.py                        | 181 ++++--
 ard/viz/layout.py                            |  24 +
 test/ard/system/geometry/test_constraints.py |   6 +-
 test/ard/unit/layout/test_boundary.py        | 278 +++++++-
 test/ard/unit/layout/test_exclusion.py       | 644 +++++++++++++++++++
 test/ard/unit/utils/test_geometry.py         | 191 +++++-
 7 files changed, 1361 insertions(+), 91 deletions(-)
 create mode 100644 ard/layout/exclusions.py
 create mode 100644 test/ard/unit/layout/test_exclusion.py

diff --git a/ard/layout/exclusions.py b/ard/layout/exclusions.py
new file mode 100644
index 00000000..f84501cd
--- /dev/null
+++ b/ard/layout/exclusions.py
@@ -0,0 +1,128 @@
+import numpy as np
+import jax.numpy as jnp
+import jax
+
+jax.config.update("jax_enable_x64", True)
+import ard.utils.geometry
+import openmdao.api as om
+
+
+class FarmExclusionDistancePolygon(om.ExplicitComponent):
+    """
+    A class to return distances between turbines and a polygonal exclusion, or
+    sets of polygonal exclusion regions.
+
+    Options
+    -------
+    modeling_options : dict
+        a modeling options dictionary
+
+    Inputs
+    ------
+    x_turbines : np.ndarray
+        a 1D numpy array indicating the x-dimension locations of the turbines,
+        with length `N_turbines` (mirrored w.r.t. `FarmAeroTemplate`)
+    y_turbines : np.ndarray
+        a 1D numpy array indicating the y-dimension locations of the turbines,
+        with length `N_turbines` (mirrored w.r.t. `FarmAeroTemplate`)
+    """
+
+    def initialize(self):
+        """Initialization of the OpenMDAO component."""
+        self.options.declare("modeling_options")
+
+    def setup(self):
+        """Setup of the OpenMDAO component."""
+
+        # load modeling options
+        self.modeling_options = self.options["modeling_options"]
+        self.windIO = self.modeling_options["windIO_plant"]
+        self.N_turbines = int(self.modeling_options["layout"]["N_turbines"])
+
+        # load exclusion vertices from windIO file
+        if "exclusions" not in self.windIO["site"]:
+            raise KeyError(
+                "You have requested an exclusion but no exclusions were found in the windIO file."
+            )
+        if "circle" in self.windIO["site"]["exclusions"]:
+            raise NotImplementedError(
+                "The circular exclusions from windIO have not been implemented here, yet."
+            )
+        if "polygons" not in self.windIO["site"]["exclusions"]:
+            raise KeyError(
+                "Currently only polygon exclusions from windIO have been implemented and none were found."
+            )
+        self.exclusion_vertices = [
+            np.array(
+                [
+                    polygon["x"],
+                    polygon["y"],
+                ]
+            ).T
+            for polygon in self.windIO["site"]["exclusions"]["polygons"]
+        ]
+        self.exclusion_regions = self.modeling_options.get("exclusions", {}).get(
+            "turbine_exclusion_assignments",  # get the exclusion region assignments from modeling_options, if there
+            np.zeros(self.N_turbines, dtype=int),  # default to zero for all turbines
+        )
+
+        # prep the jacobian
+        self.distance_multi_point_to_multi_polygon_ray_casting_jac = jax.jacfwd(
+            ard.utils.geometry.distance_multi_point_to_multi_polygon_ray_casting, [0, 1]
+        )
+
+        # set up inputs and outputs for turbine exclusion distances
+        self.add_input(
+            "x_turbines", jnp.zeros((self.N_turbines,)), units="m"
+        )  # x location of the turbines in m w.r.t. reference coordinates
+        self.add_input(
+            "y_turbines", jnp.zeros((self.N_turbines,)), units="m"
+        )  # y location of the turbines in m w.r.t. reference coordinates
+
+        self.add_output(
+            "exclusion_distances",
+            jnp.zeros(self.N_turbines),
+            units="m",
+        )
+
+    def setup_partials(self):
+        """Derivative setup for the OpenMDAO component."""
+        # the default (but not preferred!) derivatives are FDM
+        self.declare_partials(
+            "*",
+            "*",
+            method="exact",
+            rows=np.arange(self.N_turbines),
+            cols=np.arange(self.N_turbines),
+        )
+
+    def compute(self, inputs, outputs, discrete_inputs=None, discrete_outputs=None):
+        """Computation for the OpenMDAO component."""
+
+        # unpack the working variables
+        x_turbines = inputs["x_turbines"]
+        y_turbines = inputs["y_turbines"]
+
+        exclusion_distances = (
+            ard.utils.geometry.distance_multi_point_to_multi_polygon_ray_casting(
+                x_turbines,
+                y_turbines,
+                boundary_vertices=self.exclusion_vertices,
+                regions=self.exclusion_regions,
+            )
+        )
+
+        outputs["exclusion_distances"] = -exclusion_distances
+
+    def compute_partials(self, inputs, partials, discrete_inputs=None):
+
+        # unpack the working variables
+        x_turbines = inputs["x_turbines"]
+        y_turbines = inputs["y_turbines"]
+
+        jacobian = self.distance_multi_point_to_multi_polygon_ray_casting_jac(
+            x_turbines, y_turbines, self.exclusion_vertices, self.exclusion_regions
+        )
+
+        partials["exclusion_distances", "x_turbines"] = -jacobian[0].diagonal()
+        partials["exclusion_distances", "y_turbines"] = -jacobian[1].diagonal()
diff --git a/ard/utils/geometry.py b/ard/utils/geometry.py
index da5e0a8c..92279191 100644
--- a/ard/utils/geometry.py
+++ b/ard/utils/geometry.py
@@ -70,6 +70,12 @@ def get_nearest_polygons(
     return region
 
 
+# Pad all polygons to have the same number of vertices
+def pad_polygon(polygon, max_vertices):
+    padding = max_vertices - len(polygon)
+    return jnp.pad(polygon, ((0, padding), (0, 0)), mode="edge")
+
+
 def distance_multi_point_to_multi_polygon_ray_casting(
     points_x: np.ndarray[float],
     points_y: np.ndarray[float],
@@ -97,35 +103,38 @@ def distance_multi_point_to_multi_polygon_ray_casting(
         np.ndarray: Constraint values for each turbine.
         np.ndarray (optional): Region assignments for each turbine (if `return_region` is True).
     """
-
     # Combine points_x and points_y into a single array of points
     points = jnp.stack([points_x, points_y], axis=1)
 
-    # Determine the maximum number of vertices in any polygon
-    max_vertices = max(len(polygon) for polygon in boundary_vertices)
+    # Convert boundary_vertices to JAX arrays
+    boundary_vertices_jax = [
+        jnp.asarray(poly, dtype=jnp.float32) for poly in boundary_vertices
+    ]
 
-    # Pad all polygons to have the same number of vertices
-    def pad_polygon(polygon):
-        padding = max_vertices - len(polygon)
-        return jnp.pad(polygon, ((0, padding), (0, 0)))
+    # Create a function for each polygon that computes distance
+    def make_distance_func(vertices):
+        def compute_for_polygon(point):
+            return distance_point_to_polygon_ray_casting(
+                point=point,
+                vertices=vertices,
+                s=s,
+                shift=tol,
+                return_distance=True,
+            )
 
-    padded_boundary_vertices = jnp.stack(
-        [pad_polygon(polygon) for polygon in boundary_vertices]
-    )
+        return compute_for_polygon
+
+    # Create list of functions, one per polygon
+    distance_funcs = [
+        make_distance_func(vertices) for vertices in boundary_vertices_jax
+    ]
 
-    # Define a function to compute the distance for a single point and its assigned region
+    # Define function to compute distance using jax.lax.switch
     def compute_distance(point, region_idx):
-        vertices = padded_boundary_vertices[region_idx]
-        return distance_point_to_polygon_ray_casting(
-            point=point,
-            vertices=vertices,
-            s=s,
-            shift=tol,
-            return_distance=True,
-        )
+        return jax.lax.switch(region_idx, distance_funcs, point)
 
-    # Vectorize the computation over all points
-    distances = jax.vmap(compute_distance, in_axes=(0, 0))(points, regions)
+    # Vectorize over all points
+    distances = jax.vmap(compute_distance)(points, regions)
 
     return distances
 
@@ -135,6 +144,68 @@ def compute_distance(point, region_idx):
 )
 
 
+# Define a function to process a single edge
+def process_edge(
+    edge_start: jnp.ndarray,
+    edge_end: jnp.ndarray,
+    point: jnp.ndarray,
+    shift: float,
+):
+    """
+    Process a single polygon edge for ray-casting algorithm.
+
+    Determines if a vertical ray cast from the point up intersects
+    the edge, and calculates the distance from the point to the edge segment.
+
+    Args:
+        edge_start (jnp.ndarray): Start vertex of the edge ([x, y]).
+        edge_end (jnp.ndarray): End vertex of the edge ([x, y]).
+        point (jnp.ndarray): Point of interest ([x, y]).
+        shift (float): Small value added to avoid division by zero when edge is vertical.
+
+    Returns:
+        tuple: A tuple containing:
+            - is_below (bool): True if point is below the edge at the ray intersection.
+            - distance (float): Shortest distance from point to the edge segment.
+            - vertex_crossing (int): 1 if ray crosses exactly at edge_start vertex, 0 otherwise.
+    """
+
+    # Check if the x-coordinate of the point is between the x-coordinates of the edge,
+    # including when the point is directly below a vertical edge
+    x_condition = (
+        ((edge_start[0] <= point[0]) & (point[0] < edge_end[0]))
+        | ((edge_start[0] >= point[0]) & (point[0] > edge_end[0]))
+        | (
+            (
+                jnp.isclose(edge_start[0], edge_end[0])
+                & jnp.isclose(point[0], edge_start[0])
+            )
+        )
+    )
+
+    # Calculate the y-coordinate of the edge at the x-coordinate of the point
+    y = ((edge_end[1] - edge_start[1]) / (edge_end[0] - edge_start[0] + shift)) * (
+        point[0] - edge_start[0] + shift
+    ) + edge_start[1]
+
+    # Determine if the point is below the edge
+    is_below = x_condition & (point[1] < y)
+
+    # record vertex crossings
+    vertex_crossing = jnp.where(
+        x_condition & (edge_start[0] == point[0]) & is_below, 1, 0
+    )
+
+    # Calculate the distance to the edge
+    distance = distance_point_to_lineseg_nd(point, edge_start, edge_end)
+
+    return is_below, distance, vertex_crossing
+
+
+# Vectorize the edge processing function
+process_edge_vec = jax.vmap(process_edge, in_axes=(0, 0, None, None))
+
+
 def distance_point_to_polygon_ray_casting(
     point: jnp.ndarray,
     vertices: jnp.ndarray,
@@ -164,6 +235,7 @@ def distance_point_to_polygon_ray_casting(
     Returns:
         float: Signed distance or inside/outside status. Negative if inside, positive if outside.
     """
+
     # Ensure inputs are JAX arrays with explicit data types
     point = jnp.asarray(point, dtype=jnp.float32)
     vertices = jnp.asarray(vertices, dtype=jnp.float32)
@@ -171,52 +243,39 @@ def distance_point_to_polygon_ray_casting(
     # Add the first vertex to the end to close the polygon loop
     vertices = jnp.vstack([vertices, vertices[0]])
 
-    # Define a function to process a single edge
-    def process_edge(edge_start, edge_end, point):
-        # Check if the x-coordinate of the point is between the x-coordinates of the edge
-        x_condition = ((edge_start[0] <= point[0]) & (point[0] < edge_end[0])) | (
-            (edge_start[0] >= point[0]) & (point[0] > edge_end[0])
-        )
-
-        # Calculate the y-coordinate of the edge at the x-coordinate of the point
-        y = (edge_end[1] - edge_start[1]) / (edge_end[0] - edge_start[0] + shift) * (
-            point[0] - edge_start[0]
-        ) + edge_start[1]
-
-        # Determine if the point is below the edge
-        is_below = x_condition & (point[1] < y)
-
-        # Calculate the distance to the edge
-        distance = distance_point_to_lineseg_nd(point, edge_start, edge_end)
-
-        return is_below, distance
-
-    # Vectorize the edge processing function
-    process_edge_vec = jax.vmap(process_edge, in_axes=(0, 0, None))
-
     edge_starts = vertices[:-1]
     edge_ends = vertices[1:]
-    is_below, distances = process_edge_vec(edge_starts, edge_ends, point)
+    is_below, distances, vertex_crossings = process_edge_vec(
+        edge_starts, edge_ends, point, shift
+    )
+
+    # Check for tangential vertex crossings
+    # Create arrays of current and previous edge differences
+    curr_edge_end_diff = edge_ends[:, 0] - point[0]
+    prev_edge_start_diff = (
+        jnp.roll(edge_starts[:, 0], 1) - point[0]
+    )  # Shift by 1 to get previous
+    # Tangential crossing occurs when vertex_crossing > 0 AND the other two connected vertices are on same side
+    tangential_vertex_crossings = jnp.where(
+        (vertex_crossings > 0) & (curr_edge_end_diff * prev_edge_start_diff > 0), 1, 0
+    )
 
-    # Count the number of intersections
-    intersection_counter = jnp.sum(is_below)
+    # Count the number of intersections, ignoring tangential vertex crossings
+    intersection_counter = jnp.sum(is_below) - jnp.sum(tangential_vertex_crossings)
 
-    # Compute the signed distance
+    # Compute the signed distance if desired
     if return_distance:
-        c = smooth_min(distances, s=s)
-        c = jax.lax.cond(
-            intersection_counter % 2 == 1,
-            lambda _: -c,
-            lambda _: c,
-            operand=None,
-        )
+        c_prime = smooth_min(distances, s=s)
     else:
-        c = jax.lax.cond(
-            intersection_counter % 2 == 1,
-            lambda _: -1.0,
-            lambda _: 1.0,
-            operand=None,
-        )
+        c_prime = 1
+
+    c = jax.lax.cond(
+        intersection_counter % 2 == 1,
+        lambda _: -c_prime,
+        lambda _: c_prime,
+        operand=None,
+    )
+
     return c
 
 
diff --git a/ard/viz/layout.py b/ard/viz/layout.py
index 2afc07a1..f26530df 100644
--- a/ard/viz/layout.py
+++ b/ard/viz/layout.py
@@ -104,6 +104,30 @@ def plot_layout(
         # linecolor="k",
     )
 
+    # loop over the exclusion types
+    for excl_type_key, excl_type_value in (
+        windIO_dict["site"].get("exclusions", {}).items()
+    ):
+        # handle un-implemented exclusion types
+        if excl_type_key not in ["polygons"]:
+            raise NotImplementedError(
+                f"`{excl_type_key}` exclusions found but not yet handled in Ard plotting capabilities."
+            )
+
+        if excl_type_key == "polygons":
+            for polygon_exclusion in excl_type_value:
+                ax.fill(
+                    polygon_exclusion["x"],
+                    polygon_exclusion["y"],
+                    linestyle="--",
+                    alpha=0.25,
+                    fill=True,
+                    c="r",
+                    # linecolor="k",
+                )
+        else:
+            raise ValueError("this line should be inaccessible.")
+
     # plot turbines
     ax.plot(x_turbines, y_turbines, "ok")
 
diff --git a/test/ard/system/geometry/test_constraints.py b/test/ard/system/geometry/test_constraints.py
index 1ae0646c..0564ee3d 100644
--- a/test/ard/system/geometry/test_constraints.py
+++ b/test/ard/system/geometry/test_constraints.py
@@ -116,7 +116,7 @@ def test_constraint_evaluation(self, subtests):
 
     def test_constraint_optimization(self, subtests):
         """test boundary-constrained optimization distances (yes derivatives)"""
-
+        # TODO I think this test is not formulated correctly
         # setup the working/design variables
         self.prob.model.add_design_var("spacing_target", lower=2.0, upper=13.0)
         self.prob.model.add_constraint("boundary_distances", upper=0.0)
@@ -143,8 +143,8 @@ def test_constraint_optimization(self, subtests):
             )
 
         # make sure the target spacing matches well
-        spacing_target_validation = 5.46721656  # from a run on 24 June 2025
-        area_target_validation = 10.49498327  # from a run on 24 June 2025
+        spacing_target_validation = 5.46727038  # from a run on 15 Jan 2026
+        area_target_validation = 10.4951899  # from a run on 15 Jan 2026
         with subtests.test("validation spacing matches"):
             assert np.isclose(
                 self.prob.get_val("spacing_target"), spacing_target_validation
diff --git a/test/ard/unit/layout/test_boundary.py b/test/ard/unit/layout/test_boundary.py
index 53c5026a..4aa56430 100644
--- a/test/ard/unit/layout/test_boundary.py
+++ b/test/ard/unit/layout/test_boundary.py
@@ -1,12 +1,9 @@
 import numpy as np
 import openmdao.api as om
 
-import matplotlib.pyplot as plt
-
 import pytest
 
 import ard.layout.boundary as boundary
-import ard.utils.geometry as geometry
 
 
 @pytest.mark.usefixtures("subtests")
@@ -30,9 +27,7 @@ def setup_method(self):
 
         self.N_turbines = len(self.x_turbines)
 
-    def test_single_polygon_distance(self):
-
-        region_assignments_single = np.zeros(self.N_turbines, dtype=int)
+    def test_single_rectangle_distance(self):
 
         # set modeling options
         modeling_options_single = {
@@ -85,9 +80,7 @@ def test_single_polygon_distance(self):
             prob_single["boundary_distances"], expected_distances, atol=1e-3
         )
 
-    def test_single_polygon_derivatives(self, subtests):
-
-        region_assignments_single = np.zeros(self.N_turbines, dtype=int)
+    def test_single_rectangle_derivatives(self, subtests):
 
         # set modeling options
         modeling_options_single = {
@@ -180,6 +173,255 @@ def test_single_polygon_derivatives(self, subtests):
                 atol=1e-3,
             )
 
+    def test_single_reversed_rectangle_distance(self):
+        """make sure the boundaries work agnostic to boundary direction"""
+
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "boundaries": {
+                        "polygons": [
+                            {
+                                "x": [0.0, 1000.0, 1000.0, 0.0],
+                                "y": [1000.0, 1000.0, 0.0, 0.0],
+                            },
+                        ]
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "boundary",
+            boundary.FarmBoundaryDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(
+            [0.0, 0.0, 0.0, 0.0, -400.0, -200.0, 0.0, -200.0, -200.0]
+        )
+
+        assert np.allclose(
+            prob_single["boundary_distances"], expected_distances, atol=1e-3
+        )
+
+    def test_single_triangle_distance(self):
+        """make sure the boundaries work agnostic to boundary direction"""
+
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "boundaries": {
+                        "polygons": [
+                            {
+                                "x": [0.0, 1000.0, 0.0],
+                                "y": [0.0, 1000.0, 1000.0],
+                            },
+                        ]
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "boundary",
+            boundary.FarmBoundaryDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(
+            [
+                0.0,  # 0
+                282.842712474619,  # 1
+                565.685424949238,  # 2
+                0.0,  # 3
+                0.0,  # 4
+                282.842712474619,  # 5
+                0.0,  # 6
+                -200.00000000000,  # 7
+                0.0,  # 8
+            ]
+        )
+
+        assert np.allclose(
+            prob_single["boundary_distances"], expected_distances, atol=1e-3
+        )
+
+    def test_offset_triangle_distance(self):
+        """make sure boundaries not on the origin are working"""
+        bx = [0.0, 800.0, 0.0]
+        by = [1000.0, 1000.0, 200.0]
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "boundaries": {
+                        "polygons": [
+                            {
+                                "x": bx,
+                                "y": by,
+                                # "y": [200.0, 1000.0, 1000.0],
+                            },
+                        ]
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "boundary",
+            boundary.FarmBoundaryDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(
+            [
+                200.000000000000,  # 0
+                424.2640687119286,  # 1
+                707.1067811865476,  # 2
+                0.000000000000,  # 3
+                141.4213562373095,  # 4
+                424.2640687119286,  # 5
+                0.000000000000,  # 6
+                -141.4213562373095,  # 7
+                141.4213562373095,  # 8
+            ]
+        )
+
+        assert np.allclose(
+            prob_single["boundary_distances"], expected_distances, atol=1e-3
+        )
+
+    def test_offset_triangle_distance_left(self):
+        """make sure boundaries not on the origin are working"""
+        bx = [800.0, 0.0, 800.0]
+        by = [1000.0, 1000.0, 200.0]
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "boundaries": {
+                        "polygons": [
+                            {
+                                "x": bx,
+                                "y": by,
+                            },
+                        ]
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "boundary",
+            boundary.FarmBoundaryDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(  # minus sign on the data from exclusion
+            [
+                707.1067811865476,  # 0
+                424.2640687119286,  # 1
+                200.0,  # 2
+                424.2640687119286,  # 3
+                141.4213562373095,  # 4
+                0.0,  # 5
+                141.4213562373095,  # 6
+                -141.4213562373095,  # 7
+                0.0,  # 8
+            ]
+        )
+
+        assert np.allclose(
+            prob_single["boundary_distances"], expected_distances, atol=1e-3
+        )
+
     def test_multi_polygon_distance(self):
 
         boundary_vertices_0 = np.array(
@@ -201,11 +443,15 @@ def test_multi_polygon_distance(self):
             ]
         )
 
-        boundary_vertices = [boundary_vertices_0, boundary_vertices_1]
-
         region_assignments = np.ones(self.N_turbines, dtype=int)
         region_assignments[0:3] = 0
 
+        bx1 = boundary_vertices_0[:, 0].tolist()
+        by1 = boundary_vertices_0[:, 1].tolist()
+
+        bx2 = boundary_vertices_1[:, 0].tolist()
+        by2 = boundary_vertices_1[:, 1].tolist()
+
         # set modeling options
         modeling_options_multi = {
             "windIO_plant": {
@@ -215,12 +461,12 @@ def test_multi_polygon_distance(self):
                     "boundaries": {
                         "polygons": [
                             {
-                                "x": boundary_vertices_0[:, 0].tolist(),
-                                "y": boundary_vertices_0[:, 1].tolist(),
+                                "x": bx1,
+                                "y": by1,
                             },
                             {
-                                "x": boundary_vertices_1[:, 0].tolist(),
-                                "y": boundary_vertices_1[:, 1].tolist(),
+                                "x": bx2,
+                                "y": by2,
                             },
                         ]
                     },
@@ -284,8 +530,6 @@ def test_multi_polygon_derivatives(self, subtests):
             ]
         )
 
-        boundary_vertices = [boundary_vertices_0, boundary_vertices_1]
-
         region_assignments = np.ones(self.N_turbines, dtype=int)
         region_assignments[0:3] = 0
 
diff --git a/test/ard/unit/layout/test_exclusion.py b/test/ard/unit/layout/test_exclusion.py
new file mode 100644
index 00000000..5dac7611
--- /dev/null
+++ b/test/ard/unit/layout/test_exclusion.py
@@ -0,0 +1,644 @@
+import numpy as np
+import openmdao.api as om
+
+import pytest
+
+import ard.layout.exclusions as exclusions
+
+
+@pytest.mark.usefixtures("subtests")
+class TestFarmExclusionDistancePolygon:
+    """
+    Test the FarmExclusionDistancePolygon component.
+    """
+
+    def setup_method(self):
+
+        self.D_rotor = 100.0
+
+        # set turbine layout (3x3 grid 5D spacing)
+        X, Y = [
+            4.0 * self.D_rotor * v
+            for v in np.meshgrid(np.arange(0, 3), np.arange(0, 3))
+        ]
+
+        self.x_turbines = X.flatten()
+        self.y_turbines = Y.flatten()
+
+        self.N_turbines = len(self.x_turbines)
+
+    def test_single_trapezoid_distance(self):
+
+        # set modeling options
+        ex = [0.0, 600.0, 1000.0, 1000.0]
+        ey = [0.0, 0.0, 400.0, 1000.0]
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "exclusions": {
+                        "polygons": [
+                            {
+                                "x": ex,
+                                "y": ey,
+                            },
+                        ],
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "exclusions",
+            exclusions.FarmExclusionDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(
+            [
+                0.000000000000,
+                0.000000000000,
+                -141.4213562373095,
+                -282.842712474619,
+                0.000000000000,
+                141.4213562373095,
+                -565.685424949238,
+                -282.842712474619,
+                0.0000000000000,
+            ]
+        )
+        assert np.allclose(
+            prob_single["exclusion_distances"], expected_distances, atol=1e-3
+        )
+
+    def test_single_trapezoid_derivatives(self, subtests):
+
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "exclusions": {
+                        "polygons": [
+                            {
+                                "x": [0.0, 600.0, 1000.0, 1000.0],
+                                "y": [0.0, 0.0, 400.0, 1000.0],
+                            },
+                        ],
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    },
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "exclusions",
+            exclusions.FarmExclusionDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        derivatives_computed = prob_single.compute_totals(
+            of=["exclusion_distances"],
+            wrt=["x_turbines", "y_turbines"],
+        )
+
+        derivatives_expected = {
+            ("exclusion_distances", "x_turbines"): np.array(
+                [
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        -0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        -0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.70710678,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.70710678,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                ]
+            ),
+            ("exclusion_distances", "y_turbines"): np.array(
+                [
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        -0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.70710678,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        -0.70710678,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        -0.70710678,
+                        0.00000000,
+                    ],
+                    [
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                        0.00000000,
+                    ],
+                ]
+            ),
+        }
+
+        # assert a match
+        with subtests.test("wrt x_turbines"):
+            assert np.allclose(
+                derivatives_computed[("exclusion_distances", "x_turbines")],
+                derivatives_expected[("exclusion_distances", "x_turbines")],
+                atol=1e-3,
+            )
+        with subtests.test("wrt y_turbines"):
+            assert np.allclose(
+                derivatives_computed[("exclusion_distances", "y_turbines")],
+                derivatives_expected[("exclusion_distances", "y_turbines")],
+                atol=1e-3,
+            )
+
+    def test_single_triangle_distance(self):
+
+        # set modeling options
+        modeling_options_single = {
+            "windIO_plant": {
+                "name": "unit test dummy",
+                "site": {
+                    "name": "unit test site",
+                    "exclusions": {
+                        "polygons": [
+                            {
+                                "x": [0.0, 800.0, 0.0],
+                                "y": [200.0, 1000.0, 1000.0],
+                            },
+                        ],
+                    },
+                },
+                "wind_farm": {
+                    "turbine": {
+                        "rotor_diameter": self.D_rotor,
+                    }
+                },
+            },
+            "layout": {
+                "N_turbines": self.N_turbines,
+            },
+        }
+
+        # set up openmdao problem
+        model_single = om.Group()
+        model_single.add_subsystem(
+            "exclusions",
+            exclusions.FarmExclusionDistancePolygon(
+                modeling_options=modeling_options_single,
+            ),
+            promotes=["*"],
+        )
+        prob_single = om.Problem(model_single)
+        prob_single.setup()
+
+        prob_single.set_val("x_turbines", self.x_turbines)
+        prob_single.set_val("y_turbines", self.y_turbines)
+
+        prob_single.run_model()
+
+        expected_distances = np.array(
+            [
+                -200.000000000000,  # 0
+                -424.2640687119286,  # 1
+                -707.1067811865476,  # 2
+                0.000000000000,  # 3
+                -141.4213562373095,  # 4
+                -424.2640687119286,  # 5
+                0.000000000000,  # 6
+                141.4213562373095,  # 7
+                -141.4213562373095,  # 8
+            ]
+        )
+
+        assert np.allclose(
+            prob_single["exclusion_distances"], expected_distances, atol=1e-3
+        )
+
+
+#     def test_multi_polygon_distance(self):
+#
+#         boundary_vertices_0 = np.array(
+#             [
+#                 [0.0, 0.0],
+#                 [600.0, 0.0],
+#                 [1000.0, 400.0],
+#                 [1000.0, 1000.0],
+#             ]
+#         )
+#
+#         boundary_vertices_1 = np.array(
+#             [
+#                 [0.0, 200.0],
+#                 [800.0, 1000.0],
+#                 [0.0, 1000.0],
+#             ]
+#         )
+#
+#         region_assignments = np.ones(self.N_turbines, dtype=int)
+#         region_assignments[0:3] = 0
+#
+#         # set modeling options
+#         modeling_options_multi = {
+#             "windIO_plant": {
+#                 "name": "unit test dummy",
+#                 "site": {
+#                     "name": "unit test site",
+#                     "exclusions": {
+#                         "polygons": [
+#                             {
+#                                 "x": boundary_vertices_0[:, 0].tolist(),
+#                                 "y": boundary_vertices_0[:, 1].tolist(),
+#                             },
+#                             {
+#                                 "x": boundary_vertices_1[:, 0].tolist(),
+#                                 "y": boundary_vertices_1[:, 1].tolist(),
+#                             },
+#                         ]
+#                     },
+#                 },
+#                 "wind_farm": {
+#                     "turbine": {
+#                         "rotor_diameter": self.D_rotor,
+#                     }
+#                 },
+#             },
+#             "layout": {
+#                 "N_turbines": self.N_turbines,
+#             },
+#             "exclusions": {
+#                 "turbine_exclusion_assignments": region_assignments,
+#             },
+#         }
+#
+#         # set up openmdao problem
+#         model = om.Group()
+#         model.add_subsystem(
+#             "exclusions",
+#             exclusions.FarmExclusionDistancePolygon(
+#                 modeling_options=modeling_options_multi,
+#             ),
+#             promotes=["*"],
+#         )
+#         prob = om.Problem(model)
+#         prob.setup()
+#
+#         prob.set_val("x_turbines", self.x_turbines)
+#         prob.set_val("y_turbines", self.y_turbines)
+#
+#         prob.run_model()
+#
+#         print(f"DEBUG!!!!! x_turbines: {self.x_turbines}")
+#         print(f"DEBUG!!!!! y_turbines: {self.y_turbines}")
+#         print(f"DEBUG!!!!! region_assignments: {region_assignments}")
+#
+#         expected_distances = np.array(
+#             [
+#                 0.000000000000,
+#                 0.000000000000,
+#                 -141.4213562373095,
+#                 0.000000000000,
+#                 -141.4213562373095,
+#                 -424.2640687119286,
+#                 0.000000000000,
+#                 141.4213562373095,
+#                 -141.4213562373095,
+#             ]
+#         )
+#
+#         # assert a match: loose tolerance for turbines in corners due to using the smooth min
+#         assert np.allclose(prob["exclusion_distances"], expected_distances, atol=1e-2)
+#
+#     def test_multi_polygon_derivatives(self, subtests):
+#
+#         boundary_vertices_0 = np.array(
+#             [
+#                 [0.0, 0.0],
+#                 [1000.0, 0.0],
+#                 [1000.0, 200.0],
+#                 [0.0, 200.0],
+#             ]
+#         )
+#
+#         boundary_vertices_1 = np.array(
+#             [
+#                 [0.0, 300.0],
+#                 [1000.0, 300.0],
+#                 [1000.0, 1000.0],
+#                 [1100.0, 1100.0],
+#                 [0.0, 1100.0],
+#             ]
+#         )
+#
+#         region_assignments = np.ones(self.N_turbines, dtype=int)
+#         region_assignments[0:3] = 0
+#
+#         # set modeling options
+#         modeling_options_multi = {
+#             "windIO_plant": {
+#                 "name": "unit test dummy",
+#                 "site": {
+#                     "name": "unit test site",
+#                     "exclusions": {
+#                         "polygons": [
+#                             {
+#                                 "x": boundary_vertices_0[:, 0].tolist(),
+#                                 "y": boundary_vertices_0[:, 1].tolist(),
+#                             },
+#                             {
+#                                 "x": boundary_vertices_1[:, 0].tolist(),
+#                                 "y": boundary_vertices_1[:, 1].tolist(),
+#                             },
+#                         ]
+#                     },
+#                 },
+#                 "wind_farm": {
+#                     "turbine": {
+#                         "rotor_diameter": self.D_rotor,
+#                     }
+#                 },
+#             },
+#             "layout": {
+#                 "N_turbines": self.N_turbines,
+#             },
+#             "exclusions": {
+#                 "turbine_exclusion_assignments": region_assignments,
+#             },
+#         }
+#
+#         # set up openmdao problem
+#         model = om.Group()
+#         model.add_subsystem(
+#             "exclusions",
+#             exclusions.FarmExclusionDistancePolygon(
+#                 modeling_options=modeling_options_multi,
+#             ),
+#             promotes=["*"],
+#         )
+#         prob = om.Problem(model)
+#         prob.setup()
+#
+#         prob.set_val("x_turbines", self.x_turbines)
+#         prob.set_val("y_turbines", self.y_turbines)
+#
+#         prob.run_model()
+#
+#         derivatives_computed = prob.compute_totals(
+#             of=["exclusion_distances"],
+#             wrt=["x_turbines", "y_turbines"],
+#         )
+#
+#         derivatives_expected = {
+#             ("exclusion_distances", "x_turbines"): -np.array(
+#                 [
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+#                 ]
+#             ),
+#             ("exclusion_distances", "y_turbines"): -np.array(
+#                 [
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+#                     [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+#                 ]
+#             ),
+#         }
+#
+#         # assert a match
+#         with subtests.test("wrt x_turbines"):
+#             assert np.allclose(
+#                 derivatives_computed[("exclusion_distances", "x_turbines")],
+#                 derivatives_expected[("exclusion_distances", "x_turbines")],
+#                 atol=1e-3,
+#             )
+#         with subtests.test("wrt y_turbines"):
+#             assert np.allclose(
+#                 derivatives_computed[("exclusion_distances", "y_turbines")],
+#                 derivatives_expected[("exclusion_distances", "y_turbines")],
+#                 atol=1e-3,
+#             )
diff --git a/test/ard/unit/utils/test_geometry.py b/test/ard/unit/utils/test_geometry.py
index dce168d2..83340987 100644
--- a/test/ard/unit/utils/test_geometry.py
+++ b/test/ard/unit/utils/test_geometry.py
@@ -4,6 +4,49 @@
 import pytest
 
 
+@pytest.mark.usefixtures("subtests")
+class TestPadPolygon:
+
+    def test_zero_vertex(self, subtests):
+        boundary_vertices = [
+            np.array([[0.0, 0.0], [1000.0, 0.0], [1000.0, 200.0], [0.0, 200.0]]),
+            np.array(
+                [
+                    [0.0, 300.0],
+                    [1000.0, 300.0],
+                    [1000.0, 1000.0],
+                    [1100.0, 1100.0],
+                    [0.0, 1100.0],
+                ]
+            ),
+        ]
+
+        padded_expected_vertices = [
+            np.array(
+                [[0.0, 0.0], [1000.0, 0.0], [1000.0, 200.0], [0.0, 200.0], [0.0, 200.0]]
+            ),
+            np.array(
+                [
+                    [0.0, 300.0],
+                    [1000.0, 300.0],
+                    [1000.0, 1000.0],
+                    [1100.0, 1100.0],
+                    [0.0, 1100.0],
+                ]
+            ),
+        ]
+
+        max_vertices = max(len(polygon) for polygon in boundary_vertices)
+
+        with subtests.test("boundary 0"):
+            paded_polygon = geo_utils.pad_polygon(boundary_vertices[0], max_vertices)
+            assert np.allclose(paded_polygon, padded_expected_vertices[0])
+
+        with subtests.test("boundary 1"):
+            paded_polygon = geo_utils.pad_polygon(boundary_vertices[1], max_vertices)
+            assert np.allclose(paded_polygon, padded_expected_vertices[1])
+
+
 @pytest.mark.usefixtures("subtests")
 class TestGetNearestPolygons:
     """
@@ -55,7 +98,9 @@ def setup_method(self):
         )
         pass
 
-    def test_distance_multi_point_to_multi_polygon_inside_outside_single_region(self):
+    def test_distance_multi_point_to_multi_polygon_inside_outside_single_square_region(
+        self,
+    ):
 
         points = np.array([[0.25, 0.5], [1.5, 0.5]])
         polygons = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])
@@ -71,6 +116,44 @@ def test_distance_multi_point_to_multi_polygon_inside_outside_single_region(self
 
         assert np.allclose(test_result, expected_distance)
 
+    def test_distance_multi_point_to_multi_polygon_inside_outside_single_offsettriangle_region(
+        self,
+    ):
+
+        points = np.array(
+            [
+                [0.2, 0.6],
+                [0.6, 0.2],
+                [0.4, 0.8],
+                [0.8, 0.8],
+            ]
+        )
+        polygons = [
+            np.array(
+                [
+                    [0.0, 0.2],
+                    [0.8, 1.0],
+                    [0.0, 1.0],
+                ]
+            )
+        ]
+
+        expected_distance = [
+            -0.1 * np.sqrt(2),
+            0.3 * np.sqrt(2),
+            -0.1 * np.sqrt(2),
+            0.1 * np.sqrt(2),
+        ]
+
+        test_result = geo_utils.distance_multi_point_to_multi_polygon_ray_casting(
+            boundary_vertices=polygons,
+            points_x=points[:, 0],
+            points_y=points[:, 1],
+            regions=np.array([0, 0, 0, 0]),
+        )
+
+        assert np.allclose(test_result, expected_distance)
+
     def test_distance_multi_point_to_multi_polygon_inside_outside_multiple_regions(
         self,
     ):
@@ -148,20 +231,108 @@ def setup_method(self):
         )
         pass
 
-    def test_distance_point_to_polygon_inside(self):
+    def test_distance_point_to_unitsquare_inside(self, subtests):
 
-        point = np.array([0.25, 0.5])
         polygon = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])
 
-        expected_distance = -0.25
+        for idx_point, (point, expected_distance) in enumerate(
+            [(np.array([0.25, 0.5]), -0.25)]
+        ):
 
-        test_result = geo_utils.distance_point_to_polygon_ray_casting(
-            point, vertices=polygon
+            with subtests.test(f"point {idx_point}"):
+                test_result = geo_utils.distance_point_to_polygon_ray_casting(
+                    point, vertices=polygon
+                )
+                assert test_result == pytest.approx(expected_distance)
+
+    def test_distance_point_to_offsettriangle_inside(self, subtests):
+
+        polygon = np.array([[0.0, 0.2], [0.8, 1.0], [0.0, 1.0]])
+
+        for idx_point, (point, expected_distance) in enumerate(
+            [
+                (np.array([0.2, 0.6]), -0.14142135623730953),
+                (np.array([0.4, 0.8]), -0.14142135623730953),
+                (np.array([0.8, 0.8]), 0.14142135623730953),
+            ]
+        ):
+
+            with subtests.test(f"point {idx_point}"):
+                test_result = geo_utils.distance_point_to_polygon_ray_casting(
+                    point, vertices=polygon
+                )
+                assert test_result == pytest.approx(expected_distance)
+
+    def test_process_edge_multiple(self, subtests):
+
+        polygon = np.array([[0.0, 0.2], [0.8, 1.0], [0.0, 1.0]])
+        point = np.array([0.8, 0.8])
+        expected_below = [False, False, True]
+
+        for idx_end_point, end_point in enumerate(polygon):
+
+            with subtests.test(f"end point {idx_end_point}"):
+                start_point = polygon[idx_end_point - 1]
+                is_below, distance, vertex_crossing = geo_utils.process_edge(
+                    edge_start=start_point, edge_end=end_point, point=point, shift=1e-10
+                )
+                assert is_below == expected_below[idx_end_point]
+
+    def test_process_edge_multiple_above(self, subtests):
+
+        polygon = np.array([[0.8, 1.0], [0.0, 0.2], [0.8, 0.2]])
+        point = np.array([0.0, 0.8])
+        expected_below = [False, False, False]
+
+        for idx_end_point, end_point in enumerate(polygon):
+
+            with subtests.test(f"end point {idx_end_point}"):
+                start_point = polygon[idx_end_point - 1]
+                is_below, distance, vertex_crossing = geo_utils.process_edge(
+                    edge_start=start_point, edge_end=end_point, point=point, shift=1e-10
+                )
+                assert is_below == expected_below[idx_end_point]
+
+        for idx_end_point, end_point in enumerate(polygon):
+
+            with subtests.test(f"end point {idx_end_point}"):
+                start_point = polygon[idx_end_point - 1]
+                is_below, distance, vertex_crossing = geo_utils.process_edge(
+                    edge_start=start_point, edge_end=end_point, point=point, shift=1e-10
+                )
+                assert vertex_crossing == 0.0
+
+    def test_process_edge_single(self, subtests):
+
+        line = np.array([[0.8, 1.0], [0.0, 1.0]])
+        point = np.array([0.8, 0.8])
+
+        is_below, distance, vertex_crossing = geo_utils.process_edge(
+            edge_start=line[0], edge_end=line[1], point=point, shift=1e-10
         )
+        with subtests.test(f"test below edge"):
+            assert is_below == True
+        with subtests.test(f"test vertex crossing"):
+            assert vertex_crossing == True
+        with subtests.test(f"test distance"):
+            assert distance == pytest.approx(0.2, rel=1e-7)
 
-        assert test_result == pytest.approx(expected_distance)
+    def test_process_edge_single_colinear(self, subtests):
+
+        line = np.array([[0.8, 1.0], [0.0, 1.0]])
+        point = np.array([0.4, 1.0])
+
+        is_below, distance, vertex_crossing = geo_utils.process_edge(
+            edge_start=line[0], edge_end=line[1], point=point, shift=1e-10
+        )
+        with subtests.test(f"test below edge"):
+            assert is_below == False
+        with subtests.test(f"test vertex crossing"):
+            assert vertex_crossing == 0
+        with subtests.test(f"test distance"):
+            assert distance == pytest.approx(0.0, rel=1e-7)
 
-    def test_distance_point_to_polygon_center(self):
+    def test_distance_point_to_unitsquare_center(self):
 
         point = np.array([0.5, 0.5])
         polygon = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])
@@ -174,7 +345,7 @@ def test_distance_point_to_polygon_center(self):
 
         assert test_result == pytest.approx(expected_distance, rel=1e-2)
 
-    def test_distance_point_to_polygon_outside(self):
+    def test_distance_point_to_unitsquare_outside(self):
 
         point = np.array([-0.5, 0.5])
         polygon = np.array([[0, 0], [1, 0], [1, 1], [0, 1]])
@@ -187,7 +358,7 @@ def test_distance_point_to_polygon_outside(self):
 
         assert test_result == pytest.approx(expected_distance, rel=1e-2)
 
-    def test_distance_point_to_polygon_grad_2d(self, subtests):
+    def test_distance_point_to_unitsquare_grad_2d(self, subtests):
 
         point = np.array([-0.25, 0.5], dtype=float)
         polygon = np.array([[0, 0], [1, 0], [1, 1], [0, 1]], dtype=float)

From 031589d24caec9257267cc96902b566f458b3c74 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 20 Jan 2026 12:58:19 -0700
Subject: [PATCH 12/30] Black reformat update to 2026 stable format (#173)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* update for WISDEM/ORBIT pyrite standard value changes

* black v2026 reformat

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 ard/layout/sunflower.py               | 1 -
 ard/layout/viewshed.py                | 1 -
 test/ard/unit/layout/test_viewshed.py | 1 -
 3 files changed, 3 deletions(-)

diff --git a/ard/layout/sunflower.py b/ard/layout/sunflower.py
index 809b44f5..ab47d15f 100644
--- a/ard/layout/sunflower.py
+++ b/ard/layout/sunflower.py
@@ -4,7 +4,6 @@
 import ard.layout.templates as templates
 import ard.layout.fullfarm as fullfarm
 
-
 phi_golden = (1 + np.sqrt(5)) / 2  # golden ratio
 
 
diff --git a/ard/layout/viewshed.py b/ard/layout/viewshed.py
index ff6611d6..ef0e7f21 100644
--- a/ard/layout/viewshed.py
+++ b/ard/layout/viewshed.py
@@ -5,7 +5,6 @@
 
 import openmdao.api as om
 
-
 _R_earth = 6371008.8  # Earth radius, m
 
 
diff --git a/test/ard/unit/layout/test_viewshed.py b/test/ard/unit/layout/test_viewshed.py
index 450db3c0..83a02736 100644
--- a/test/ard/unit/layout/test_viewshed.py
+++ b/test/ard/unit/layout/test_viewshed.py
@@ -2,7 +2,6 @@
 import numpy as np
 from ard.layout import viewshed
 
-
 ## HELPER FUNCTION TESTING
 
 

From 52a7ce853b4d680e87ea50f7a0570fc610164ffa Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 20 Jan 2026 20:47:21 -0700
Subject: [PATCH 13/30] Eagle density function for eco-constrained design
 setups (#168)

* bring in the exclusions and their viz implications

* added exclusion code

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* added eagle density code and tested it

* fix filepath

* improved documentation, added and tested derivatives on eagles splines

* black reformat

* first tranche of copilot changes

* second tranche of copilot fixes

* Apply suggestions from copilot code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* more consistent error messages

* black reformat

* new gold standard test, weird failure

* fixed value of the exclusion distance; still failing now on two: mysterious sign flip, sometimes...

* add a boundary test case that lights up the strange error

* rename and add some tests

* added exclusion test even though it's in tatters

* debugging

* use switch instead of pad to fix boundary in/out identification. also clean up debug statements

* black reformat

* black reformat

* address jared comments

* fix accidentally stashed and dropped changes

* black reformat...

* fix calling convention

* black are you kidding me

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>
---
 ard/eco/eagle_density.py                      | 129 +++++++++++++++++
 ard/layout/exclusions.py                      |  12 +-
 ard/layout/gridfarm.py                        |   8 +-
 .../eco/inputs/ard_system_eagle_density.yaml  |   6 +
 .../ard/unit/eco/inputs/presence_density.yaml | 136 ++++++++++++++++++
 test/ard/unit/eco/test_eagle_density.py       | 105 ++++++++++++++
 6 files changed, 389 insertions(+), 7 deletions(-)
 create mode 100644 ard/eco/eagle_density.py
 create mode 100644 test/ard/unit/eco/inputs/ard_system_eagle_density.yaml
 create mode 100644 test/ard/unit/eco/inputs/presence_density.yaml
 create mode 100644 test/ard/unit/eco/test_eagle_density.py

diff --git a/ard/eco/eagle_density.py b/ard/eco/eagle_density.py
new file mode 100644
index 00000000..97226f29
--- /dev/null
+++ b/ard/eco/eagle_density.py
@@ -0,0 +1,129 @@
+import numpy as np
+from scipy.interpolate import RectBivariateSpline
+
+import openmdao.api as om
+
+
+class EagleDensityFunction(om.ExplicitComponent):
+    """
+    OpenMDAO component to evaluate eagle presence density at turbine locations.
+
+    An Ard/OpenMDAO component that evaluates the eagle presence density metric
+    calculated by the National Laboratory of the Rockies's Stochastic Soaring
+    Raptor Simulator (SSRS) at the turbine locations. The eagle presence density
+    is an output of an SSRS simulation indicating the unit density function of
+    a raptor flying through the point during a given migratory period.
+
+    Options
+    -------
+    modeling_options : dict
+        a modeling options dictionary (inherited from
+        `templates.LanduseTemplate`)
+
+    Inputs
+    ------
+    x_turbines : np.ndarray
+        a 1-D numpy array that represents the x (i.e. Easting) coordinate of
+        the location of each of the turbines in the farm in meters
+    y_turbines : np.ndarray
+        a 1-D numpy array that represents the y (i.e. Northing) coordinate of
+        the location of each of the turbines in the farm in meters
+
+    Outputs
+    -------
+    eagle_normalized_density : np.ndarray
+        a 1-D numpy array that represents the normalized eagle presence density
+        at each of the turbine locations (unitless)
+    """
+
+    def initialize(self):
+        """Initialization of OM component."""
+        self.options.declare("modeling_options")
+
+    def setup(self):
+        """Setup of OM component."""
+
+        # load modeling options and turbine count
+        modeling_options = self.modeling_options = self.options["modeling_options"]
+
+        self.N_turbines = modeling_options["layout"]["N_turbines"]
+
+        # grab the eagle presence density settings
+        self.pres = self.modeling_options["eco"]["eagle_presence_density_map"]
+        self.eagle_density_function = RectBivariateSpline(
+            self.pres["x"], self.pres["y"], self.pres["normalized_presence_density"]
+        )
+        self.eagle_density_function_dx = self.eagle_density_function.partial_derivative(
+            dx=1, dy=0
+        )
+        self.eagle_density_function_dy = self.eagle_density_function.partial_derivative(
+            dx=0, dy=1
+        )
+
+        # add the full layout inputs
+        self.add_input(
+            "x_turbines",
+            np.zeros((self.N_turbines,)),
+            units="m",
+            desc="turbine location in x-direction",
+        )
+        self.add_input(
+            "y_turbines",
+            np.zeros((self.N_turbines,)),
+            units="m",
+            desc="turbine location in y-direction",
+        )
+
+        # add outputs that are universal
+        self.add_output(
+            "eagle_normalized_density",
+            np.zeros((self.N_turbines,)),
+            units=None,
+            desc="normalized eagle presence density",
+        )
+
+    def setup_partials(self):
+        """Setup the OpenMDAO component partial derivatives."""
+        self.declare_partials(
+            "eagle_normalized_density",
+            "x_turbines",
+            diagonal=True,
+            method="exact",
+        )
+        self.declare_partials(
+            "eagle_normalized_density",
+            "y_turbines",
+            diagonal=True,
+            method="exact",
+        )
+
+    def compute(self, inputs, outputs):
+        """
+        Computation for the OM component.
+        """
+
+        # unpack the turbine locations
+        x_turbines = inputs["x_turbines"]  # m
+        y_turbines = inputs["y_turbines"]  # m
+
+        # evaluate the density function at each turbine point
+        outputs["eagle_normalized_density"] = self.eagle_density_function(
+            x_turbines,
+            y_turbines,
+            grid=False,
+        )
+
+    def compute_partials(self, inputs, partials):
+        """
+        Compute the partials for the OM component
+        """
+
+        # unpack the turbine locations
+        x_turbines = inputs["x_turbines"]  # m
+        y_turbines = inputs["y_turbines"]  # m
+
+        # evaluate the gradients for each variable
+        dfdx = self.eagle_density_function_dx(x_turbines, y_turbines, grid=False)
+        dfdy = self.eagle_density_function_dy(x_turbines, y_turbines, grid=False)
+        partials["eagle_normalized_density", "x_turbines"] = dfdx
+        partials["eagle_normalized_density", "y_turbines"] = dfdy
diff --git a/ard/layout/exclusions.py b/ard/layout/exclusions.py
index f84501cd..a482b432 100644
--- a/ard/layout/exclusions.py
+++ b/ard/layout/exclusions.py
@@ -25,6 +25,12 @@ class FarmExclusionDistancePolygon(om.ExplicitComponent):
     y_turbines : np.ndarray
         a 1D numpy array indicating the y-dimension locations of the turbines,
         with length `N_turbines` (mirrored w.r.t. `FarmAeroTemplate`)
+
+    Outputs
+    -------
+    exclusion_distances : np.ndarray
+        a 1D array of distances (in meters) from each turbine to its assigned
+        polygonal exclusion region
     """
 
     def initialize(self):
@@ -49,7 +55,7 @@ def setup(self):
                 "The circular exclusions from windIO have not been implemented here, yet."
             )
         if "polygons" not in self.windIO["site"]["exclusions"]:
-            raise KeyError(
+            raise NotImplementedError(
                 "Currently only polygon exclusions from windIO have been implemented and none were found."
             )
         self.exclusion_vertices = [
@@ -62,7 +68,7 @@ def setup(self):
             for polygon in self.windIO["site"]["exclusions"]["polygons"]
         ]
         self.exclusion_regions = self.modeling_options.get("exclusions", {}).get(
-            "turbine_exclusion_assignments",  # get the exclusion region assignments from modeling_options, if there
+            "turbine_exclusion_assignments",  # exclusion region assignments, if there
             np.zeros(self.N_turbines, dtype=int),  # default to zero for all turbines
         )
 
@@ -87,7 +93,7 @@ def setup(self):
 
     def setup_partials(self):
         """Derivative setup for the OpenMDAO component."""
-        # the default (but not preferred!) derivatives are FDM
+        # override the OpenMDAO default FDM derivatives by declaring exact derivatives
         self.declare_partials(
             "*",
             "*",
diff --git a/ard/layout/gridfarm.py b/ard/layout/gridfarm.py
index e76ac2a2..acc5e6b0 100644
--- a/ard/layout/gridfarm.py
+++ b/ard/layout/gridfarm.py
@@ -91,8 +91,8 @@ def setup(self):
         angle_skew = self.modeling_options["layout"]["angle_skew"]
 
         # add four-parameter grid farm layout DVs
-        self.add_input("spacing_primary", spacing_primary, units="unitless")
-        self.add_input("spacing_secondary", spacing_secondary, units="unitless")
+        self.add_input("spacing_primary", spacing_primary, units=None)
+        self.add_input("spacing_secondary", spacing_secondary, units=None)
         self.add_input("angle_orientation", angle_orientation, units="deg")
         self.add_input("angle_skew", angle_skew, units="deg")
 
@@ -227,13 +227,13 @@ def setup(self):
         self.add_input(
             "spacing_primary",
             self.modeling_options["layout"]["spacing_primary"],
-            units="unitless",
+            units=None,
             desc="turbine row spacing in rotor diameters",
         )
         self.add_input(
             "spacing_secondary",
             self.modeling_options["layout"]["spacing_secondary"],
-            units="unitless",
+            units=None,
             desc="turbine column spacing (along rows) in rotor diameters",
         )
         self.add_input(
diff --git a/test/ard/unit/eco/inputs/ard_system_eagle_density.yaml b/test/ard/unit/eco/inputs/ard_system_eagle_density.yaml
new file mode 100644
index 00000000..615c2faf
--- /dev/null
+++ b/test/ard/unit/eco/inputs/ard_system_eagle_density.yaml
@@ -0,0 +1,6 @@
+modeling_options: &modeling_options
+  windIO_plant:
+  layout:
+    N_turbines: 9
+  eco:
+    eagle_presence_density_map: !include presence_density.yaml
diff --git a/test/ard/unit/eco/inputs/presence_density.yaml b/test/ard/unit/eco/inputs/presence_density.yaml
new file mode 100644
index 00000000..262129cc
--- /dev/null
+++ b/test/ard/unit/eco/inputs/presence_density.yaml
@@ -0,0 +1,136 @@
+x:
+  - -1000.000
+  -  -950.000
+  -  -900.000
+  -  -850.000
+  -  -800.000
+  -  -750.000
+  -  -700.000
+  -  -650.000
+  -  -600.000
+  -  -550.000
+  -  -500.000
+  -  -450.000
+  -  -400.000
+  -  -350.000
+  -  -300.000
+  -  -250.000
+  -  -200.000
+  -  -150.000
+  -  -100.000
+  -   -50.000
+  -     0.000
+  -    50.000
+  -   100.000
+  -   150.000
+  -   200.000
+  -   250.000
+  -   300.000
+  -   350.000
+  -   400.000
+  -   450.000
+  -   500.000
+  -   550.000
+  -   600.000
+  -   650.000
+  -   700.000
+  -   750.000
+  -   800.000
+  -   850.000
+  -   900.000
+  -   950.000
+  -  1000.000
+y:
+  - -1000.000
+  -  -960.000
+  -  -920.000
+  -  -880.000
+  -  -840.000
+  -  -800.000
+  -  -760.000
+  -  -720.000
+  -  -680.000
+  -  -640.000
+  -  -600.000
+  -  -560.000
+  -  -520.000
+  -  -480.000
+  -  -440.000
+  -  -400.000
+  -  -360.000
+  -  -320.000
+  -  -280.000
+  -  -240.000
+  -  -200.000
+  -  -160.000
+  -  -120.000
+  -   -80.000
+  -   -40.000
+  -     0.000
+  -    40.000
+  -    80.000
+  -   120.000
+  -   160.000
+  -   200.000
+  -   240.000
+  -   280.000
+  -   320.000
+  -   360.000
+  -   400.000
+  -   440.000
+  -   480.000
+  -   520.000
+  -   560.000
+  -   600.000
+  -   640.000
+  -   680.000
+  -   720.000
+  -   760.000
+  -   800.000
+  -   840.000
+  -   880.000
+  -   920.000
+  -   960.000
+  -  1000.000
+normalized_presence_density:
+  - [   -2.3431457505,   -2.1415284956,   -1.9503079195,   -1.7693357423,   -1.5984551305,   -1.4375006101,   -1.2862980902,   -1.1446650238,   -1.0124107335,   -0.8893369345,   -0.7752384841,   -0.6699043898,   -0.5731191028,   -0.4846641204,   -0.4043199092,   -0.3318681543,   -0.2670943182,   -0.2097904805,   -0.1597584046,   -0.1168127577,   -0.0807843891,   -0.0515235516,   -0.0289029402,   -0.0128204147,   -0.0032012790,    0.0000000000,   -0.0032012790,   -0.0128204147,   -0.0289029402,   -0.0515235516,   -0.0807843891,   -0.1168127577,   -0.1597584046,   -0.2097904805,   -0.2670943182,   -0.3318681543,   -0.4043199092,   -0.4846641204,   -0.5731191028,   -0.6699043898,   -0.7752384841,   -0.8893369345,   -1.0124107335,   -1.1446650238,   -1.2862980902,   -1.4375006101,   -1.5984551305,   -1.7693357423,   -1.9503079195,   -2.1415284956,   -2.3431457505]
+  - [   -2.0927543103,   -1.8940301496,   -1.7057606830,   -1.5277930538,   -1.3599646875,   -1.2021030607,   -1.0540255796,   -0.9155395977,   -0.7864426091,   -0.6665226555,   -0.5555589892,   -0.4533230340,   -0.3595796861,   -0.2740889900,   -0.1966082191,   -0.1268943744,   -0.0647070982,   -0.0098119757,    0.0380158320,    0.0789877073,    0.1132975678,    0.1411178733,    0.1625958174,    0.1778498817,    0.1869669294,    0.1900000000,    0.1869669294,    0.1778498817,    0.1625958174,    0.1411178733,    0.1132975678,    0.0789877073,    0.0380158320,   -0.0098119757,   -0.0647070982,   -0.1268943744,   -0.1966082191,   -0.2740889900,   -0.3595796861,   -0.4533230340,   -0.5555589892,   -0.6665226555,   -0.7864426091,   -0.9155395977,   -1.0540255796,   -1.2021030607,   -1.3599646875,   -1.5277930538,   -1.7057606830,   -1.8940301496,   -2.0927543103]
+  - [   -1.8585503812,   -1.6627890721,   -1.4775518262,   -1.3026819272,   -1.1380117131,   -0.9833621685,   -0.8385426168,   -0.7033505490,   -0.5775716313,   -0.4609799385,   -0.3533384694,   -0.2544000000,   -0.1639083327,   -0.0816000000,   -0.0072064684,    0.0595431207,    0.1189186611,    0.1711852596,    0.2165989337,    0.2554019271,    0.2878177829,    0.3140463622,    0.3342590281,    0.3485942394,    0.3571538015,    0.3600000000,    0.3571538015,    0.3485942394,    0.3342590281,    0.3140463622,    0.2878177829,    0.2554019271,    0.2165989337,    0.1711852596,    0.1189186611,    0.0595431207,   -0.0072064684,   -0.0816000000,   -0.1639083327,   -0.2544000000,   -0.3533384694,   -0.4609799385,   -0.5775716313,   -0.7033505490,   -0.8385426168,   -0.9833621685,   -1.1380117131,   -1.3026819272,   -1.4775518262,   -1.6627890721,   -1.8585503812]
+  - [   -1.6402381006,   -1.4475014828,   -1.2653704643,   -1.0936854115,   -0.9322744786,   -0.7809529880,   -0.6395228914,   -0.5077723552,   -0.3854755185,   -0.2723924812,   -0.1682695907,   -0.0728401024,    0.0141747051,    0.0930638780,    0.1641245200,    0.2276588456,    0.2839705123,    0.3333602255,    0.3761206595,    0.4125307947,    0.4428498393,    0.4673109706,    0.4861151891,    0.4994256222,    0.5073626239,    0.5100000000,    0.5073626239,    0.4994256222,    0.4861151891,    0.4673109706,    0.4428498393,    0.4125307947,    0.3761206595,    0.3333602255,    0.2839705123,    0.2276588456,    0.1641245200,    0.0930638780,    0.0141747051,   -0.0728401024,   -0.1682695907,   -0.2723924812,   -0.3854755185,   -0.5077723552,   -0.6395228914,   -0.7809529880,   -0.9322744786,   -1.0936854115,   -1.2653704643,   -1.4475014828,   -1.6402381006]
+  - [   -1.4375006101,   -1.2478402074,   -1.0688797907,   -0.9004580009,   -0.7424000000,   -0.5945166004,   -0.4566034483,   -0.3284403049,   -0.2097904805,   -0.1004004880,    0.0000000000,    0.0916977970,    0.1749953414,    0.2502092127,    0.3176679074,    0.3777087640,    0.4306739519,    0.4769054766,    0.5167392161,    0.5504980829,    0.5784845005,    0.6009724887,    0.6181997466,    0.6303601988,    0.6375975031,    0.6400000000,    0.6375975031,    0.6303601988,    0.6181997466,    0.6009724887,    0.5784845005,    0.5504980829,    0.5167392161,    0.4769054766,    0.4306739519,    0.3777087640,    0.3176679074,    0.2502092127,    0.1749953414,    0.0916977970,    0.0000000000,   -0.1004004880,   -0.2097904805,   -0.3284403049,   -0.4566034483,   -0.5945166004,   -0.7424000000,   -0.9004580009,   -1.0688797907,   -1.2478402074,   -1.4375006101]
+  - [   -1.2500000000,   -1.0634542790,   -0.8877162609,   -0.7226243244,   -0.5680021490,   -0.4236575601,   -0.2893813861,   -0.1649463717,   -0.0501062045,    0.0554052690,    0.1518745425,    0.2396085470,    0.3189342075,    0.3901972991,    0.4537604333,    0.5100000000,    0.5593019097,    0.6020560211,    0.6386492095,    0.6694571396,    0.6948349393,    0.7151071312,    0.7305573363,    0.7414183957,    0.7478636369,    0.7500000000,    0.7478636369,    0.7414183957,    0.7305573363,    0.7151071312,    0.6948349393,    0.6694571396,    0.6386492095,    0.6020560211,    0.5593019097,    0.5100000000,    0.4537604333,    0.3901972991,    0.3189342075,    0.2396085470,    0.1518745425,    0.0554052690,   -0.0501062045,   -0.1649463717,   -0.2893813861,   -0.4236575601,   -0.5680021490,   -0.7226243244,   -0.8877162609,   -1.0634542790,   -1.2500000000]
+  - [   -1.0773777537,   -0.8939690431,   -0.7214892747,   -0.5597783050,   -0.4086601815,   -0.2679416749,   -0.1374107670,   -0.0168351326,    0.0940393276,    0.1954898244,    0.2878177829,    0.3713495730,    0.4464366971,    0.5134552278,    0.5728042574,    0.6249030993,    0.6701869847,    0.7091010248,    0.7420922920,    0.7696000000,    0.7920439557,    0.8098116914,    0.8232449447,    0.8326263926,    0.8381677029,    0.8400000000,    0.8381677029,    0.8326263926,    0.8232449447,    0.8098116914,    0.7920439557,    0.7696000000,    0.7420922920,    0.7091010248,    0.6701869847,    0.6249030993,    0.5728042574,    0.5134552278,    0.4464366971,    0.3713495730,    0.2878177829,    0.1954898244,    0.0940393276,   -0.0168351326,   -0.1374107670,   -0.2679416749,   -0.4086601815,   -0.5597783050,   -0.7214892747,   -0.8939690431,   -1.0773777537]
+  - [   -0.9192558232,   -0.7389869280,   -0.5697815394,   -0.4114829997,   -0.2639179181,   -0.1268943744,   -0.0002000050,    0.1164000000,    0.2231649408,    0.3203806182,    0.4083612026,    0.4874508126,    0.5580246035,    0.6204891077,    0.6752815125,    0.7228675045,    0.7637372781,    0.7983993099,    0.8273715647,    0.8511699522,    0.8702941017,    0.8852108754,    0.8963364591,    0.9040182928,    0.9085184248,    0.9100000000,    0.9085184248,    0.9040182928,    0.8963364591,    0.8852108754,    0.8702941017,    0.8511699522,    0.8273715647,    0.7983993099,    0.7637372781,    0.7228675045,    0.6752815125,    0.6204891077,    0.5580246035,    0.4874508126,    0.4083612026,    0.3203806182,    0.2231649408,    0.1164000000,   -0.0002000050,   -0.1268943744,   -0.2639179181,   -0.4114829997,   -0.5697815394,   -0.7389869280,   -0.9192558232]
+  - [   -0.7752384841,   -0.5980890566,   -0.4321503303,   -0.2772713742,   -0.1332838718,    0.0000000000,    0.1227898998,    0.2353198444,    0.3378508956,    0.4306739519,    0.5141125497,    0.5885255246,    0.6543093186,    0.7118996340,    0.7617720380,    0.8044410204,    0.8404569095,    0.8704000000,    0.8948712572,    0.9144791074,    0.9298221281,    0.9414679514,    0.9499293665,    0.9556393521,    0.9589274205,    0.9600000000,    0.9589274205,    0.9556393521,    0.9499293665,    0.9414679514,    0.9298221281,    0.9144791074,    0.8948712572,    0.8704000000,    0.8404569095,    0.8044410204,    0.7617720380,    0.7118996340,    0.6543093186,    0.5885255246,    0.5141125497,    0.4306739519,    0.3378508956,    0.2353198444,    0.1227898998,    0.0000000000,   -0.1332838718,   -0.2772713742,   -0.4321503303,   -0.5980890566,   -0.7752384841]
+  - [   -0.6449151158,   -0.4708378888,   -0.3081298835,   -0.1566483019,   -0.0162326728,    0.1132975678,    0.2321458025,    0.3405412776,    0.4387424647,    0.5270407120,    0.6057641192,    0.6752815125,    0.7360063152,    0.7884000000,    0.8329746645,    0.8702941017,    0.9009725487,    0.9256701232,    0.9450838599,    0.9599333102,    0.9709399821,    0.9788005587,    0.9841548712,    0.9875509171,    0.9894105086,    0.9900000000,    0.9894105086,    0.9875509171,    0.9841548712,    0.9788005587,    0.9709399821,    0.9599333102,    0.9450838599,    0.9256701232,    0.9009725487,    0.8702941017,    0.8329746645,    0.7884000000,    0.7360063152,    0.6752815125,    0.6057641192,    0.5270407120,    0.4387424647,    0.3405412776,    0.2321458025,    0.1132975678,   -0.0162326728,   -0.1566483019,   -0.3081298835,   -0.4708378888,   -0.6449151158]
+  - [   -0.5278640450,   -0.3567810791,   -0.1972351639,   -0.0490941028,    0.0877918112,    0.2135924528,    0.3285009330,    0.4327371201,    0.5265516554,    0.6102304807,    0.6840998704,    0.7485319007,    0.8039502075,    0.8508357522,    0.8897321289,    0.9212496950,    0.9460674881,    0.9649315327,    0.9786478051,    0.9880679398,    0.9940659229,    0.9975047597,    0.9991936211,    0.9998382242,    0.9999897926,    1.0000000000,    0.9999897926,    0.9998382242,    0.9991936211,    0.9975047597,    0.9940659229,    0.9880679398,    0.9786478051,    0.9649315327,    0.9460674881,    0.9212496950,    0.8897321289,    0.8508357522,    0.8039502075,    0.7485319007,    0.6840998704,    0.6102304807,    0.5265516554,    0.4327371201,    0.3285009330,    0.2135924528,    0.0877918112,   -0.0490941028,   -0.1972351639,   -0.3567810791,   -0.5278640450]
+  - [   -0.4236575601,   -0.2554567087,   -0.0989672364,    0.0459300682,    0.1793712418,    0.3015119501,    0.4125307947,    0.5126332075,    0.6020560211,    0.6810727991,    0.7500000000,    0.8092040089,    0.8591089995,    0.9002054639,    0.9330590364,    0.9583189158,    0.9767247255,    0.9891100308,    0.9964000000,    0.9996000000,    0.9997715604,    0.9979926298,    0.9953009636,    0.9926231811,    0.9906971197,    0.9900000000,    0.9906971197,    0.9926231811,    0.9953009636,    0.9979926298,    0.9997715604,    0.9996000000,    0.9964000000,    0.9891100308,    0.9767247255,    0.9583189158,    0.9330590364,    0.9002054639,    0.8591089995,    0.8092040089,    0.7500000000,    0.6810727991,    0.6020560211,    0.5126332075,    0.4125307947,    0.3015119501,    0.1793712418,    0.0459300682,   -0.0989672364,   -0.2554567087,   -0.4236575601]
+  - [   -0.3318681543,   -0.1664000000,   -0.0128204147,    0.1289747116,    0.2591050719,    0.3777087640,    0.4849456886,    0.5810016451,    0.6660932677,    0.7404739623,    0.8044410204,    0.8583440855,    0.9025951147,    0.9376798963,    0.9641709996,    0.9827416998,    0.9941798475,    0.9993997560,    0.9994488985,    0.9955046064,    0.9888543820,    0.9808527383,    0.9728490414,    0.9660862443,    0.9615800994,    0.9600000000,    0.9615800994,    0.9660862443,    0.9728490414,    0.9808527383,    0.9888543820,    0.9955046064,    0.9994488985,    0.9993997560,    0.9941798475,    0.9827416998,    0.9641709996,    0.9376798963,    0.9025951147,    0.8583440855,    0.8044410204,    0.7404739623,    0.6660932677,    0.5810016451,    0.4849456886,    0.3777087640,    0.2591050719,    0.1289747116,   -0.0128204147,   -0.1664000000,   -0.3318681543]
+  - [   -0.2520759799,   -0.0891515368,    0.0617087255,    0.2005921810,    0.3276000000,    0.4428498393,    0.5464791433,    0.6386492095,    0.7195502088,    0.7894073960,    0.8484887979,    0.8971147170,    0.9356694311,    0.9646154784,    0.9845108475,    0.9960291625,    0.9999824337,    0.9973449122,    0.9892747865,    0.9771276139,    0.9624515497,    0.9469505124,    0.9324000000,    0.9205058457,    0.9127131963,    0.9100000000,    0.9127131963,    0.9205058457,    0.9324000000,    0.9469505124,    0.9624515497,    0.9771276139,    0.9892747865,    0.9973449122,    0.9999824337,    0.9960291625,    0.9845108475,    0.9646154784,    0.9356694311,    0.8971147170,    0.8484887979,    0.7894073960,    0.7195502088,    0.6386492095,    0.5464791433,    0.4428498393,    0.3276000000,    0.2005921810,    0.0617087255,   -0.0891515368,   -0.2520759799]
+  - [   -0.1838773964,   -0.0232668926,    0.1251105291,    0.2613245757,    0.3854564994,    0.4976014981,    0.5978717145,    0.6864000000,    0.7633446682,    0.8288955275,    0.8832815730,    0.9267808279,    0.9597329632,    0.9825554717,    0.9957643129,    1.0000000000,    0.9960599222,    0.9849369760,    0.9678627623,    0.9463498170,    0.9222205102,    0.8976000000,    0.8748395537,    0.8563339757,    0.8442196760,    0.8400000000,    0.8442196760,    0.8563339757,    0.8748395537,    0.8976000000,    0.9222205102,    0.9463498170,    0.9678627623,    0.9849369760,    0.9960599222,    1.0000000000,    0.9957643129,    0.9825554717,    0.9597329632,    0.9267808279,    0.8832815730,    0.8288955275,    0.7633446682,    0.6864000000,    0.5978717145,    0.4976014981,    0.3854564994,    0.2613245757,    0.1251105291,   -0.0232668926,   -0.1838773964]
+  - [   -0.1268943744,    0.0316725800,    0.1778498817,    0.3116895485,    0.4332525783,    0.5426109228,    0.6398499902,    0.7250718420,    0.7983993099,    0.8599813418,    0.9100000000,    0.9486796970,    0.9762994779,    0.9932094604,    0.9998529486,    0.9967962264,    0.9847685601,    0.9647152403,    0.9378659503,    0.9058178761,    0.8706248475,    0.8348657664,    0.8016339699,    0.7743523799,    0.7563191121,    0.7500000000,    0.7563191121,    0.7743523799,    0.8016339699,    0.8348657664,    0.8706248475,    0.9058178761,    0.9378659503,    0.9647152403,    0.9847685601,    0.9967962264,    0.9998529486,    0.9932094604,    0.9762994779,    0.9486796970,    0.9100000000,    0.8599813418,    0.7983993099,    0.7250718420,    0.6398499902,    0.5426109228,    0.4332525783,    0.3116895485,    0.1778498817,    0.0316725800,   -0.1268943744]
+  - [   -0.0807843891,    0.0760482151,    0.2203527347,    0.3521645353,    0.4715253032,    0.5784845005,    0.6731012327,    0.7554466708,    0.8256072235,    0.8836887383,    0.9298221281,    0.9641709996,    0.9869421243,    0.9984000000,    0.9988873558,    0.9888543820,    0.9689008226,    0.9398369811,    0.9027720427,    0.8592399481,    0.8113708499,    0.7620998780,    0.7153523032,    0.6760263691,    0.6494431222,    0.6400000000,    0.6494431222,    0.6760263691,    0.7153523032,    0.7620998780,    0.8113708499,    0.8592399481,    0.9027720427,    0.9398369811,    0.9689008226,    0.9888543820,    0.9988873558,    0.9984000000,    0.9869421243,    0.9641709996,    0.9298221281,    0.8836887383,    0.8256072235,    0.7554466708,    0.6731012327,    0.5784845005,    0.4715253032,    0.3521645353,    0.2203527347,    0.0760482151,   -0.0807843891]
+  - [   -0.0452503168,    0.1101923378,    0.2529922276,    0.3831702250,    0.5007510368,    0.6057641192,    0.6982448651,    0.7782361613,    0.8457904574,    0.9009725487,    0.9438633754,    0.9745652865,    0.9932094604,    0.9999665537,    0.9950622879,    0.9788007491,    0.9516000000,    0.9140477638,    0.8669904139,    0.8116777358,    0.7500000000,    0.6848684880,    0.6207749085,    0.5644000000,    0.5245669879,    0.5100000000,    0.5245669879,    0.5644000000,    0.6207749085,    0.6848684880,    0.7500000000,    0.8116777358,    0.8669904139,    0.9140477638,    0.9516000000,    0.9788007491,    0.9950622879,    0.9999665537,    0.9932094604,    0.9745652865,    0.9438633754,    0.9009725487,    0.8457904574,    0.7782361613,    0.6982448651,    0.6057641192,    0.5007510368,    0.3831702250,    0.2529922276,    0.1101923378,   -0.0452503168]
+  - [   -0.0200497516,    0.1343771238,    0.2760752964,    0.4050543721,    0.5213257572,    0.6249030993,    0.7158028635,    0.7940450953,    0.8596544444,    0.9126615585,    0.9531050121,    0.9810340245,    0.9965123672,    0.9996241075,    0.9904822676,    0.9692422502,    0.9361233354,    0.8914443691,    0.8356854998,    0.7696000000,    0.6944271910,    0.6123184906,    0.5272199741,    0.4466499390,    0.3844131846,    0.3600000000,    0.3844131846,    0.4466499390,    0.5272199741,    0.6123184906,    0.6944271910,    0.7696000000,    0.8356854998,    0.8914443691,    0.9361233354,    0.9692422502,    0.9904822676,    0.9996241075,    0.9965123672,    0.9810340245,    0.9531050121,    0.9126615585,    0.8596544444,    0.7940450953,    0.7158028635,    0.6249030993,    0.5213257572,    0.4050543721,    0.2760752964,    0.1343771238,   -0.0200497516]
+  - [   -0.0050031211,    0.1488048060,    0.2898307754,    0.4180772399,    0.5335471178,    0.6362439084,    0.7261718439,    0.8033360921,    0.8677430294,    0.9194006153,    0.9583189158,    0.9845108475,    0.9979932619,    0.9987885619,    0.9869271860,    0.9624515497,    0.9254225476,    0.8759307793,    0.8141170123,    0.7402120538,    0.6546211251,    0.5581221846,    0.4524000000,    0.3417592453,    0.2397249695,    0.1900000000,    0.2397249695,    0.3417592453,    0.4524000000,    0.5581221846,    0.6546211251,    0.7402120538,    0.8141170123,    0.8759307793,    0.9254225476,    0.9624515497,    0.9869271860,    0.9987885619,    0.9979932619,    0.9845108475,    0.9583189158,    0.9194006153,    0.8677430294,    0.8033360921,    0.7261718439,    0.6362439084,    0.5335471178,    0.4180772399,    0.2898307754,    0.1488048060,   -0.0050031211]
+  - [    0.0000000000,    0.1536000000,    0.2944000000,    0.4224000000,    0.5376000000,    0.6400000000,    0.7296000000,    0.8064000000,    0.8704000000,    0.9216000000,    0.9600000000,    0.9856000000,    0.9984000000,    0.9984000000,    0.9856000000,    0.9600000000,    0.9216000000,    0.8704000000,    0.8064000000,    0.7296000000,    0.6400000000,    0.5376000000,    0.4224000000,    0.2944000000,    0.1536000000,    0.0000000000,    0.1536000000,    0.2944000000,    0.4224000000,    0.5376000000,    0.6400000000,    0.7296000000,    0.8064000000,    0.8704000000,    0.9216000000,    0.9600000000,    0.9856000000,    0.9984000000,    0.9984000000,    0.9856000000,    0.9600000000,    0.9216000000,    0.8704000000,    0.8064000000,    0.7296000000,    0.6400000000,    0.5376000000,    0.4224000000,    0.2944000000,    0.1536000000,    0.0000000000]
+  - [   -0.0050031211,    0.1488048060,    0.2898307754,    0.4180772399,    0.5335471178,    0.6362439084,    0.7261718439,    0.8033360921,    0.8677430294,    0.9194006153,    0.9583189158,    0.9845108475,    0.9979932619,    0.9987885619,    0.9869271860,    0.9624515497,    0.9254225476,    0.8759307793,    0.8141170123,    0.7402120538,    0.6546211251,    0.5581221846,    0.4524000000,    0.3417592453,    0.2397249695,    0.1900000000,    0.2397249695,    0.3417592453,    0.4524000000,    0.5581221846,    0.6546211251,    0.7402120538,    0.8141170123,    0.8759307793,    0.9254225476,    0.9624515497,    0.9869271860,    0.9987885619,    0.9979932619,    0.9845108475,    0.9583189158,    0.9194006153,    0.8677430294,    0.8033360921,    0.7261718439,    0.6362439084,    0.5335471178,    0.4180772399,    0.2898307754,    0.1488048060,   -0.0050031211]
+  - [   -0.0200497516,    0.1343771238,    0.2760752964,    0.4050543721,    0.5213257572,    0.6249030993,    0.7158028635,    0.7940450953,    0.8596544444,    0.9126615585,    0.9531050121,    0.9810340245,    0.9965123672,    0.9996241075,    0.9904822676,    0.9692422502,    0.9361233354,    0.8914443691,    0.8356854998,    0.7696000000,    0.6944271910,    0.6123184906,    0.5272199741,    0.4466499390,    0.3844131846,    0.3600000000,    0.3844131846,    0.4466499390,    0.5272199741,    0.6123184906,    0.6944271910,    0.7696000000,    0.8356854998,    0.8914443691,    0.9361233354,    0.9692422502,    0.9904822676,    0.9996241075,    0.9965123672,    0.9810340245,    0.9531050121,    0.9126615585,    0.8596544444,    0.7940450953,    0.7158028635,    0.6249030993,    0.5213257572,    0.4050543721,    0.2760752964,    0.1343771238,   -0.0200497516]
+  - [   -0.0452503168,    0.1101923378,    0.2529922276,    0.3831702250,    0.5007510368,    0.6057641192,    0.6982448651,    0.7782361613,    0.8457904574,    0.9009725487,    0.9438633754,    0.9745652865,    0.9932094604,    0.9999665537,    0.9950622879,    0.9788007491,    0.9516000000,    0.9140477638,    0.8669904139,    0.8116777358,    0.7500000000,    0.6848684880,    0.6207749085,    0.5644000000,    0.5245669879,    0.5100000000,    0.5245669879,    0.5644000000,    0.6207749085,    0.6848684880,    0.7500000000,    0.8116777358,    0.8669904139,    0.9140477638,    0.9516000000,    0.9788007491,    0.9950622879,    0.9999665537,    0.9932094604,    0.9745652865,    0.9438633754,    0.9009725487,    0.8457904574,    0.7782361613,    0.6982448651,    0.6057641192,    0.5007510368,    0.3831702250,    0.2529922276,    0.1101923378,   -0.0452503168]
+  - [   -0.0807843891,    0.0760482151,    0.2203527347,    0.3521645353,    0.4715253032,    0.5784845005,    0.6731012327,    0.7554466708,    0.8256072235,    0.8836887383,    0.9298221281,    0.9641709996,    0.9869421243,    0.9984000000,    0.9988873558,    0.9888543820,    0.9689008226,    0.9398369811,    0.9027720427,    0.8592399481,    0.8113708499,    0.7620998780,    0.7153523032,    0.6760263691,    0.6494431222,    0.6400000000,    0.6494431222,    0.6760263691,    0.7153523032,    0.7620998780,    0.8113708499,    0.8592399481,    0.9027720427,    0.9398369811,    0.9689008226,    0.9888543820,    0.9988873558,    0.9984000000,    0.9869421243,    0.9641709996,    0.9298221281,    0.8836887383,    0.8256072235,    0.7554466708,    0.6731012327,    0.5784845005,    0.4715253032,    0.3521645353,    0.2203527347,    0.0760482151,   -0.0807843891]
+  - [   -0.1268943744,    0.0316725800,    0.1778498817,    0.3116895485,    0.4332525783,    0.5426109228,    0.6398499902,    0.7250718420,    0.7983993099,    0.8599813418,    0.9100000000,    0.9486796970,    0.9762994779,    0.9932094604,    0.9998529486,    0.9967962264,    0.9847685601,    0.9647152403,    0.9378659503,    0.9058178761,    0.8706248475,    0.8348657664,    0.8016339699,    0.7743523799,    0.7563191121,    0.7500000000,    0.7563191121,    0.7743523799,    0.8016339699,    0.8348657664,    0.8706248475,    0.9058178761,    0.9378659503,    0.9647152403,    0.9847685601,    0.9967962264,    0.9998529486,    0.9932094604,    0.9762994779,    0.9486796970,    0.9100000000,    0.8599813418,    0.7983993099,    0.7250718420,    0.6398499902,    0.5426109228,    0.4332525783,    0.3116895485,    0.1778498817,    0.0316725800,   -0.1268943744]
+  - [   -0.1838773964,   -0.0232668926,    0.1251105291,    0.2613245757,    0.3854564994,    0.4976014981,    0.5978717145,    0.6864000000,    0.7633446682,    0.8288955275,    0.8832815730,    0.9267808279,    0.9597329632,    0.9825554717,    0.9957643129,    1.0000000000,    0.9960599222,    0.9849369760,    0.9678627623,    0.9463498170,    0.9222205102,    0.8976000000,    0.8748395537,    0.8563339757,    0.8442196760,    0.8400000000,    0.8442196760,    0.8563339757,    0.8748395537,    0.8976000000,    0.9222205102,    0.9463498170,    0.9678627623,    0.9849369760,    0.9960599222,    1.0000000000,    0.9957643129,    0.9825554717,    0.9597329632,    0.9267808279,    0.8832815730,    0.8288955275,    0.7633446682,    0.6864000000,    0.5978717145,    0.4976014981,    0.3854564994,    0.2613245757,    0.1251105291,   -0.0232668926,   -0.1838773964]
+  - [   -0.2520759799,   -0.0891515368,    0.0617087255,    0.2005921810,    0.3276000000,    0.4428498393,    0.5464791433,    0.6386492095,    0.7195502088,    0.7894073960,    0.8484887979,    0.8971147170,    0.9356694311,    0.9646154784,    0.9845108475,    0.9960291625,    0.9999824337,    0.9973449122,    0.9892747865,    0.9771276139,    0.9624515497,    0.9469505124,    0.9324000000,    0.9205058457,    0.9127131963,    0.9100000000,    0.9127131963,    0.9205058457,    0.9324000000,    0.9469505124,    0.9624515497,    0.9771276139,    0.9892747865,    0.9973449122,    0.9999824337,    0.9960291625,    0.9845108475,    0.9646154784,    0.9356694311,    0.8971147170,    0.8484887979,    0.7894073960,    0.7195502088,    0.6386492095,    0.5464791433,    0.4428498393,    0.3276000000,    0.2005921810,    0.0617087255,   -0.0891515368,   -0.2520759799]
+  - [   -0.3318681543,   -0.1664000000,   -0.0128204147,    0.1289747116,    0.2591050719,    0.3777087640,    0.4849456886,    0.5810016451,    0.6660932677,    0.7404739623,    0.8044410204,    0.8583440855,    0.9025951147,    0.9376798963,    0.9641709996,    0.9827416998,    0.9941798475,    0.9993997560,    0.9994488985,    0.9955046064,    0.9888543820,    0.9808527383,    0.9728490414,    0.9660862443,    0.9615800994,    0.9600000000,    0.9615800994,    0.9660862443,    0.9728490414,    0.9808527383,    0.9888543820,    0.9955046064,    0.9994488985,    0.9993997560,    0.9941798475,    0.9827416998,    0.9641709996,    0.9376798963,    0.9025951147,    0.8583440855,    0.8044410204,    0.7404739623,    0.6660932677,    0.5810016451,    0.4849456886,    0.3777087640,    0.2591050719,    0.1289747116,   -0.0128204147,   -0.1664000000,   -0.3318681543]
+  - [   -0.4236575601,   -0.2554567087,   -0.0989672364,    0.0459300682,    0.1793712418,    0.3015119501,    0.4125307947,    0.5126332075,    0.6020560211,    0.6810727991,    0.7500000000,    0.8092040089,    0.8591089995,    0.9002054639,    0.9330590364,    0.9583189158,    0.9767247255,    0.9891100308,    0.9964000000,    0.9996000000,    0.9997715604,    0.9979926298,    0.9953009636,    0.9926231811,    0.9906971197,    0.9900000000,    0.9906971197,    0.9926231811,    0.9953009636,    0.9979926298,    0.9997715604,    0.9996000000,    0.9964000000,    0.9891100308,    0.9767247255,    0.9583189158,    0.9330590364,    0.9002054639,    0.8591089995,    0.8092040089,    0.7500000000,    0.6810727991,    0.6020560211,    0.5126332075,    0.4125307947,    0.3015119501,    0.1793712418,    0.0459300682,   -0.0989672364,   -0.2554567087,   -0.4236575601]
+  - [   -0.5278640450,   -0.3567810791,   -0.1972351639,   -0.0490941028,    0.0877918112,    0.2135924528,    0.3285009330,    0.4327371201,    0.5265516554,    0.6102304807,    0.6840998704,    0.7485319007,    0.8039502075,    0.8508357522,    0.8897321289,    0.9212496950,    0.9460674881,    0.9649315327,    0.9786478051,    0.9880679398,    0.9940659229,    0.9975047597,    0.9991936211,    0.9998382242,    0.9999897926,    1.0000000000,    0.9999897926,    0.9998382242,    0.9991936211,    0.9975047597,    0.9940659229,    0.9880679398,    0.9786478051,    0.9649315327,    0.9460674881,    0.9212496950,    0.8897321289,    0.8508357522,    0.8039502075,    0.7485319007,    0.6840998704,    0.6102304807,    0.5265516554,    0.4327371201,    0.3285009330,    0.2135924528,    0.0877918112,   -0.0490941028,   -0.1972351639,   -0.3567810791,   -0.5278640450]
+  - [   -0.6449151158,   -0.4708378888,   -0.3081298835,   -0.1566483019,   -0.0162326728,    0.1132975678,    0.2321458025,    0.3405412776,    0.4387424647,    0.5270407120,    0.6057641192,    0.6752815125,    0.7360063152,    0.7884000000,    0.8329746645,    0.8702941017,    0.9009725487,    0.9256701232,    0.9450838599,    0.9599333102,    0.9709399821,    0.9788005587,    0.9841548712,    0.9875509171,    0.9894105086,    0.9900000000,    0.9894105086,    0.9875509171,    0.9841548712,    0.9788005587,    0.9709399821,    0.9599333102,    0.9450838599,    0.9256701232,    0.9009725487,    0.8702941017,    0.8329746645,    0.7884000000,    0.7360063152,    0.6752815125,    0.6057641192,    0.5270407120,    0.4387424647,    0.3405412776,    0.2321458025,    0.1132975678,   -0.0162326728,   -0.1566483019,   -0.3081298835,   -0.4708378888,   -0.6449151158]
+  - [   -0.7752384841,   -0.5980890566,   -0.4321503303,   -0.2772713742,   -0.1332838718,    0.0000000000,    0.1227898998,    0.2353198444,    0.3378508956,    0.4306739519,    0.5141125497,    0.5885255246,    0.6543093186,    0.7118996340,    0.7617720380,    0.8044410204,    0.8404569095,    0.8704000000,    0.8948712572,    0.9144791074,    0.9298221281,    0.9414679514,    0.9499293665,    0.9556393521,    0.9589274205,    0.9600000000,    0.9589274205,    0.9556393521,    0.9499293665,    0.9414679514,    0.9298221281,    0.9144791074,    0.8948712572,    0.8704000000,    0.8404569095,    0.8044410204,    0.7617720380,    0.7118996340,    0.6543093186,    0.5885255246,    0.5141125497,    0.4306739519,    0.3378508956,    0.2353198444,    0.1227898998,    0.0000000000,   -0.1332838718,   -0.2772713742,   -0.4321503303,   -0.5980890566,   -0.7752384841]
+  - [   -0.9192558232,   -0.7389869280,   -0.5697815394,   -0.4114829997,   -0.2639179181,   -0.1268943744,   -0.0002000050,    0.1164000000,    0.2231649408,    0.3203806182,    0.4083612026,    0.4874508126,    0.5580246035,    0.6204891077,    0.6752815125,    0.7228675045,    0.7637372781,    0.7983993099,    0.8273715647,    0.8511699522,    0.8702941017,    0.8852108754,    0.8963364591,    0.9040182928,    0.9085184248,    0.9100000000,    0.9085184248,    0.9040182928,    0.8963364591,    0.8852108754,    0.8702941017,    0.8511699522,    0.8273715647,    0.7983993099,    0.7637372781,    0.7228675045,    0.6752815125,    0.6204891077,    0.5580246035,    0.4874508126,    0.4083612026,    0.3203806182,    0.2231649408,    0.1164000000,   -0.0002000050,   -0.1268943744,   -0.2639179181,   -0.4114829997,   -0.5697815394,   -0.7389869280,   -0.9192558232]
+  - [   -1.0773777537,   -0.8939690431,   -0.7214892747,   -0.5597783050,   -0.4086601815,   -0.2679416749,   -0.1374107670,   -0.0168351326,    0.0940393276,    0.1954898244,    0.2878177829,    0.3713495730,    0.4464366971,    0.5134552278,    0.5728042574,    0.6249030993,    0.6701869847,    0.7091010248,    0.7420922920,    0.7696000000,    0.7920439557,    0.8098116914,    0.8232449447,    0.8326263926,    0.8381677029,    0.8400000000,    0.8381677029,    0.8326263926,    0.8232449447,    0.8098116914,    0.7920439557,    0.7696000000,    0.7420922920,    0.7091010248,    0.6701869847,    0.6249030993,    0.5728042574,    0.5134552278,    0.4464366971,    0.3713495730,    0.2878177829,    0.1954898244,    0.0940393276,   -0.0168351326,   -0.1374107670,   -0.2679416749,   -0.4086601815,   -0.5597783050,   -0.7214892747,   -0.8939690431,   -1.0773777537]
+  - [   -1.2500000000,   -1.0634542790,   -0.8877162609,   -0.7226243244,   -0.5680021490,   -0.4236575601,   -0.2893813861,   -0.1649463717,   -0.0501062045,    0.0554052690,    0.1518745425,    0.2396085470,    0.3189342075,    0.3901972991,    0.4537604333,    0.5100000000,    0.5593019097,    0.6020560211,    0.6386492095,    0.6694571396,    0.6948349393,    0.7151071312,    0.7305573363,    0.7414183957,    0.7478636369,    0.7500000000,    0.7478636369,    0.7414183957,    0.7305573363,    0.7151071312,    0.6948349393,    0.6694571396,    0.6386492095,    0.6020560211,    0.5593019097,    0.5100000000,    0.4537604333,    0.3901972991,    0.3189342075,    0.2396085470,    0.1518745425,    0.0554052690,   -0.0501062045,   -0.1649463717,   -0.2893813861,   -0.4236575601,   -0.5680021490,   -0.7226243244,   -0.8877162609,   -1.0634542790,   -1.2500000000]
+  - [   -1.4375006101,   -1.2478402074,   -1.0688797907,   -0.9004580009,   -0.7424000000,   -0.5945166004,   -0.4566034483,   -0.3284403049,   -0.2097904805,   -0.1004004880,    0.0000000000,    0.0916977970,    0.1749953414,    0.2502092127,    0.3176679074,    0.3777087640,    0.4306739519,    0.4769054766,    0.5167392161,    0.5504980829,    0.5784845005,    0.6009724887,    0.6181997466,    0.6303601988,    0.6375975031,    0.6400000000,    0.6375975031,    0.6303601988,    0.6181997466,    0.6009724887,    0.5784845005,    0.5504980829,    0.5167392161,    0.4769054766,    0.4306739519,    0.3777087640,    0.3176679074,    0.2502092127,    0.1749953414,    0.0916977970,    0.0000000000,   -0.1004004880,   -0.2097904805,   -0.3284403049,   -0.4566034483,   -0.5945166004,   -0.7424000000,   -0.9004580009,   -1.0688797907,   -1.2478402074,   -1.4375006101]
+  - [   -1.6402381006,   -1.4475014828,   -1.2653704643,   -1.0936854115,   -0.9322744786,   -0.7809529880,   -0.6395228914,   -0.5077723552,   -0.3854755185,   -0.2723924812,   -0.1682695907,   -0.0728401024,    0.0141747051,    0.0930638780,    0.1641245200,    0.2276588456,    0.2839705123,    0.3333602255,    0.3761206595,    0.4125307947,    0.4428498393,    0.4673109706,    0.4861151891,    0.4994256222,    0.5073626239,    0.5100000000,    0.5073626239,    0.4994256222,    0.4861151891,    0.4673109706,    0.4428498393,    0.4125307947,    0.3761206595,    0.3333602255,    0.2839705123,    0.2276588456,    0.1641245200,    0.0930638780,    0.0141747051,   -0.0728401024,   -0.1682695907,   -0.2723924812,   -0.3854755185,   -0.5077723552,   -0.6395228914,   -0.7809529880,   -0.9322744786,   -1.0936854115,   -1.2653704643,   -1.4475014828,   -1.6402381006]
+  - [   -1.8585503812,   -1.6627890721,   -1.4775518262,   -1.3026819272,   -1.1380117131,   -0.9833621685,   -0.8385426168,   -0.7033505490,   -0.5775716313,   -0.4609799385,   -0.3533384694,   -0.2544000000,   -0.1639083327,   -0.0816000000,   -0.0072064684,    0.0595431207,    0.1189186611,    0.1711852596,    0.2165989337,    0.2554019271,    0.2878177829,    0.3140463622,    0.3342590281,    0.3485942394,    0.3571538015,    0.3600000000,    0.3571538015,    0.3485942394,    0.3342590281,    0.3140463622,    0.2878177829,    0.2554019271,    0.2165989337,    0.1711852596,    0.1189186611,    0.0595431207,   -0.0072064684,   -0.0816000000,   -0.1639083327,   -0.2544000000,   -0.3533384694,   -0.4609799385,   -0.5775716313,   -0.7033505490,   -0.8385426168,   -0.9833621685,   -1.1380117131,   -1.3026819272,   -1.4775518262,   -1.6627890721,   -1.8585503812]
+  - [   -2.0927543103,   -1.8940301496,   -1.7057606830,   -1.5277930538,   -1.3599646875,   -1.2021030607,   -1.0540255796,   -0.9155395977,   -0.7864426091,   -0.6665226555,   -0.5555589892,   -0.4533230340,   -0.3595796861,   -0.2740889900,   -0.1966082191,   -0.1268943744,   -0.0647070982,   -0.0098119757,    0.0380158320,    0.0789877073,    0.1132975678,    0.1411178733,    0.1625958174,    0.1778498817,    0.1869669294,    0.1900000000,    0.1869669294,    0.1778498817,    0.1625958174,    0.1411178733,    0.1132975678,    0.0789877073,    0.0380158320,   -0.0098119757,   -0.0647070982,   -0.1268943744,   -0.1966082191,   -0.2740889900,   -0.3595796861,   -0.4533230340,   -0.5555589892,   -0.6665226555,   -0.7864426091,   -0.9155395977,   -1.0540255796,   -1.2021030607,   -1.3599646875,   -1.5277930538,   -1.7057606830,   -1.8940301496,   -2.0927543103]
+  - [   -2.3431457505,   -2.1415284956,   -1.9503079195,   -1.7693357423,   -1.5984551305,   -1.4375006101,   -1.2862980902,   -1.1446650238,   -1.0124107335,   -0.8893369345,   -0.7752384841,   -0.6699043898,   -0.5731191028,   -0.4846641204,   -0.4043199092,   -0.3318681543,   -0.2670943182,   -0.2097904805,   -0.1597584046,   -0.1168127577,   -0.0807843891,   -0.0515235516,   -0.0289029402,   -0.0128204147,   -0.0032012790,    0.0000000000,   -0.0032012790,   -0.0128204147,   -0.0289029402,   -0.0515235516,   -0.0807843891,   -0.1168127577,   -0.1597584046,   -0.2097904805,   -0.2670943182,   -0.3318681543,   -0.4043199092,   -0.4846641204,   -0.5731191028,   -0.6699043898,   -0.7752384841,   -0.8893369345,   -1.0124107335,   -1.1446650238,   -1.2862980902,   -1.4375006101,   -1.5984551305,   -1.7693357423,   -1.9503079195,   -2.1415284956,   -2.3431457505]
\ No newline at end of file
diff --git a/test/ard/unit/eco/test_eagle_density.py b/test/ard/unit/eco/test_eagle_density.py
new file mode 100644
index 00000000..5870a81a
--- /dev/null
+++ b/test/ard/unit/eco/test_eagle_density.py
@@ -0,0 +1,105 @@
+from pathlib import Path
+
+import numpy as np
+
+import openmdao.api as om
+import openmdao.utils.assert_utils as om_utils
+
+from ard.utils.io import load_yaml  # we grab a yaml loader here
+from ard.eco.eagle_density import EagleDensityFunction
+
+import pytest
+
+
+@pytest.mark.usefixtures("subtests")
+class TestEagleDensityFunction:
+
+    def setup_method(self):
+
+        Rmax = 500.0  # m
+        R = lambda x, y: np.sqrt(x * x + y * y)
+        # if we wanted to add another dimension here
+        # we could add `THETA = lambda x, y: np.atan2(x, y)`
+        self.F = lambda x, y: -R(x, y) * R(x, y) / (Rmax * Rmax) + 2 * R(x, y) / Rmax
+
+        # load input
+        path_inputs = Path(__file__).parent.absolute() / "inputs"
+        input_dict = load_yaml(path_inputs / "ard_system_eagle_density.yaml")
+        modeling_options = self.modeling_options = input_dict["modeling_options"]
+
+        # create the OpenMDAO model
+        model = om.Group()
+        model.add_subsystem(
+            "eagle_density",
+            EagleDensityFunction(modeling_options=modeling_options),
+            promotes=["*"],
+        )
+
+        self.prob = om.Problem(model)
+        self.prob.setup()
+
+    def test_eagle_density(self, subtests):
+
+        F = self.F  # extract the exact function
+
+        # generated from casting random bytestreams to int
+        seeds = [2005908367, 1273391448, 2557384174, 2195599068, 1604240584]
+
+        for seed in seeds:
+
+            # create a repeatable rng
+            rng = np.random.default_rng(seed)
+
+            # evaluate the turbines in the grid
+            x_turbines = rng.uniform(
+                -1000.0, 1000.0, self.modeling_options["layout"]["N_turbines"]
+            )
+            y_turbines = rng.uniform(
+                -1000.0, 1000.0, self.modeling_options["layout"]["N_turbines"]
+            )
+            F_turbines_reference = F(x_turbines, y_turbines)
+
+            # set up the model to run
+            self.prob.set_val("x_turbines", x_turbines, units="m")
+            self.prob.set_val("y_turbines", y_turbines, units="m")
+            self.prob.run_model()
+
+            # assert that the values are close to the reference
+            with subtests.test(f"eagle_normalized_density check seed {seed}"):
+                assert np.allclose(
+                    self.prob.get_val("eagle_normalized_density"),
+                    F_turbines_reference,
+                    atol=5.0e-2,
+                )
+
+    def test_gradient_eagle_density(self, subtests):
+
+        # generated from casting random bytestreams to int
+        seeds = [2005908367, 1273391448, 2557384174, 2195599068, 1604240584]
+
+        for seed in seeds:
+
+            # create a repeatable rng
+            rng = np.random.default_rng(seed)
+
+            # evaluate the turbines in the grid
+            x_turbines = rng.uniform(
+                -1000.0, 1000.0, self.modeling_options["layout"]["N_turbines"]
+            )
+            y_turbines = rng.uniform(
+                -1000.0, 1000.0, self.modeling_options["layout"]["N_turbines"]
+            )
+
+            # set up the model to run
+            self.prob.set_val("x_turbines", x_turbines, units="m")
+            self.prob.set_val("y_turbines", y_turbines, units="m")
+            self.prob.run_model()
+
+            # check the partial derivatives
+            with subtests.test(f"eagle_normalized_density gradient check seed {seed}"):
+                partials = self.prob.check_partials(
+                    method="fd",
+                    step=1.0e-8,
+                    out_stream=None,
+                )
+                om_utils.assert_check_partials(partials)

From 5e2c43ea865ba5c6b55bfeca3bcff70abe6e8b4f Mon Sep 17 00:00:00 2001
From: Pietro Bortolotti <ptrbortolotti@gmail.com>
Date: Tue, 20 Jan 2026 21:46:46 -0700
Subject: [PATCH 14/30] update org name (#170)

Co-authored-by: Cory Frontin <cory.frontin@nrel.gov>
---
 README.md                                        | 8 ++++----
 ard/cost/orbit_wrap.py                           | 2 +-
 docs/installation.md                             | 2 +-
 docs/testing.md                                  | 4 ++--
 examples/05_onshore_batch/inputs/ard_system.yaml | 8 ++++----
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index b3f7fe1a..52e85465 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 
 # Ard
 
-[![CI/CD test suite](https://github.com/WISDEM/Ard/actions/workflows/python-tests-consolidated.yaml/badge.svg?branch=main)](https://github.com/WISDEM/Ard/actions/workflows/python-tests-consolidated.yaml)
+[![CI/CD test suite](https://github.com/NLRWindSystems/Ard/actions/workflows/python-tests-consolidated.yaml/badge.svg?branch=main)](https://github.com/NLRWindSystems/Ard/actions/workflows/python-tests-consolidated.yaml)
 
 ![Ard logo](assets/logomaker/logo.png)
 
@@ -35,7 +35,7 @@ Ard documentation is available at [https://wisdem.github.io/Ard](https://wisdem.
 
 If installing from PyPI, skip to [step 2.](#2.-Set-up-environment). If installing from source, the source can be cloned from github using the following command in your preferred location:
 ```shell
-git clone git@github.com:WISDEM/Ard.git
+git clone git@github.com:NLRWindSystems/Ard.git
 ```
 Once downloaded, you can enter the `Ard` root directory using
 ```shell
@@ -111,7 +111,7 @@ source test/run_local_test_system.sh
 These enable the generation of HTML-based coverage reports by default and can be used to track "coverage", or the percentage of software lines of code that are run by the testing systems.
 `Ard`'s git repository includes requirements for both the `main` and `develop` branches to have 80% coverage on unit testing and 50% testing in system testing, which are, respectively, tests of individual parts of `Ard` and "systems" composed of multiple parts.
 Failures are not tolerated in code that is merged onto these branches and code found therein *should* never cause a testing failure if it has been found there.
-If the process of installation and testing fails, please open a new issue [here](https://github.com/WISDEM/Ard/issues).
+If the process of installation and testing fails, please open a new issue [here](https://github.com/NLRWindSystems/Ard/issues).
 
 ## Design philosophy
 
@@ -151,7 +151,7 @@ The components that achieve this can be assembled to either run a single top-dow
 # Contributing to `Ard`
 
 We have striven towards best-practices documentation and testing for `Ard`.
-Contribution is welcome, and we are happy [to field pull requests from github](https://github.com/WISDEM/Ard/pulls).
+Contribution is welcome, and we are happy [to field pull requests from github](https://github.com/NLRWindSystems/Ard/pulls).
 For acceptance, PRs must:
 - be formatted using [`black`](https://github.com/psf/black)
 - not fail any unit tests or system tests
diff --git a/ard/cost/orbit_wrap.py b/ard/cost/orbit_wrap.py
index 4523167d..2267e082 100644
--- a/ard/cost/orbit_wrap.py
+++ b/ard/cost/orbit_wrap.py
@@ -201,7 +201,7 @@ class ORBITDetail(orbit_wisdem.Orbit):
     array layout, and 2) traps warning messages that are recognized not to be
     issues.
 
-    See: https://github.com/WISDEM/ORBIT
+    See: https://github.com/NLRWindSystems/ORBIT
     """
 
     def initialize(self):
diff --git a/docs/installation.md b/docs/installation.md
index 816bf1e8..7030b57a 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -10,7 +10,7 @@
 ### 1. Clone Ard source repository
 If installing from PyPI, skip to [step 2.](#2.-Set-up-environment). If installing from source, the source can be cloned from github using the following command in your preferred location:
 ```shell
-git clone git@github.com:WISDEM/Ard.git
+git clone git@github.com:NLRWindSystems/Ard.git
 ```
 Once downloaded, you can enter the `Ard` root directory using
 ```shell
diff --git a/docs/testing.md b/docs/testing.md
index 73e4b803..74600620 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -9,5 +9,5 @@ source test/run_local_test_system.sh
 These enable the generation of HTML-based coverage reports by default and can be used to track "coverage", or the percentage of software lines of code that are run by the testing systems.
 `Ard`'s git repository includes requirements for both the `main` and `develop` branches to have 80% coverage on unit testing and 50% testing in system testing, which are, respectively, tests of individual parts of `Ard` and "systems" composed of multiple parts.
 Failures are not tolerated in code that is merged onto these branches and code found therein *should* never cause a testing failure if it has been found there.
-If the process of installation and testing fails, please open a new issue [here](https://github.com/WISDEM/Ard/issues).
-If the process of installation and testing fails, please open a new issue [here](https://github.com/WISDEM/Ard/issues).
+If the process of installation and testing fails, please open a new issue [here](https://github.com/NLRWindSystems/Ard/issues).
+If the process of installation and testing fails, please open a new issue [here](https://github.com/NLRWindSystems/Ard/issues).
diff --git a/examples/05_onshore_batch/inputs/ard_system.yaml b/examples/05_onshore_batch/inputs/ard_system.yaml
index a5288b23..091ec743 100644
--- a/examples/05_onshore_batch/inputs/ard_system.yaml
+++ b/examples/05_onshore_batch/inputs/ard_system.yaml
@@ -30,18 +30,18 @@ modeling_options:
     rated_power: 5000000.0  # W
     num_blades: 3
     rated_thrust_N: 823484.4216152605 # from NREL 5MW definition
-    gust_velocity_m_per_s: 70.0 # from https://github.com/WISDEM/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
+    gust_velocity_m_per_s: 70.0 # from https://github.com/NLRWindSystems/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
     blade_surface_area: 69.7974979
     tower_mass: 620.4407337521
     nacelle_mass: 101.98582836439
     hub_mass: 8.38407517646
     blade_mass: 14.56341339641
     foundation_height: 0.0
-    commissioning_cost_kW: 44.0 # from https://github.com/WISDEM/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
-    decommissioning_cost_kW: 58.0 # from https://github.com/WISDEM/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
+    commissioning_cost_kW: 44.0 # from https://github.com/NLRWindSystems/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
+    decommissioning_cost_kW: 58.0 # from https://github.com/NLRWindSystems/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
     trench_len_to_substation_km: 50.0
     distance_to_interconnect_mi: 4.97096954
-    interconnect_voltage_kV: 130.0 # from https://github.com/WISDEM/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
+    interconnect_voltage_kV: 130.0 # from https://github.com/NLRWindSystems/WISDEM/blob/master/examples/02_reference_turbines/nrel5mw.yaml
     tcc_per_kW: 1300.00  # (USD/kW)
     opex_per_kW: 44.00  # (USD/kWh)
 

From f8ccba17d69967e074819e763bd58e8ca428c37b Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 3 Feb 2026 09:14:39 -0700
Subject: [PATCH 15/30] Add some helpers for "house style" plots (#174)

* create house style update
* update house style to actually work
---
 ard/__init__.py                                  |  7 +++++--
 ard/viz/house_style.py                           | 15 +++++++++++++++
 assets/house_style/stylesheet_ard.mplstyle       |  8 ++++++++
 assets/house_style/stylesheet_ard_notex.mplstyle |  7 +++++++
 assets/house_style/stylesheet_nrel.mplstyle      |  2 ++
 5 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 ard/viz/house_style.py
 create mode 100644 assets/house_style/stylesheet_ard.mplstyle
 create mode 100644 assets/house_style/stylesheet_ard_notex.mplstyle
 create mode 100644 assets/house_style/stylesheet_nrel.mplstyle

diff --git a/ard/__init__.py b/ard/__init__.py
index 0f68643f..c2cc6a17 100644
--- a/ard/__init__.py
+++ b/ard/__init__.py
@@ -1,10 +1,13 @@
+from pathlib import Path
+
 from . import collection
 from . import layout
 from . import offshore
 from . import wind_query
 from . import utils
+from . import viz
 
-from pathlib import Path
+from .viz import house_style
 
-BASE_DIR = Path(__file__).absolute().parent
+BASE_DIR = Path(__file__).parent.absolute()
 ASSET_DIR = BASE_DIR / "api" / "default_systems"
diff --git a/ard/viz/house_style.py b/ard/viz/house_style.py
new file mode 100644
index 00000000..c30b979a
--- /dev/null
+++ b/ard/viz/house_style.py
@@ -0,0 +1,15 @@
+import ard
+
+
+def get_stylesheets(use_tex=False, dark_background=True):
+    house_style_dir = ard.BASE_DIR.parent / "assets" / "house_style"
+    ard_stylesheet = (
+        house_style_dir / f"stylesheet_ard{"" if use_tex else "_notex"}.mplstyle"
+    )
+    nrel_stylesheet = house_style_dir / f"stylesheet_nrel.mplstyle"
+    styles = []
+    if dark_background:
+        styles.append("dark_background")
+    styles.append(ard_stylesheet.as_uri())
+    styles.append(nrel_stylesheet.as_uri())
+    return styles
diff --git a/assets/house_style/stylesheet_ard.mplstyle b/assets/house_style/stylesheet_ard.mplstyle
new file mode 100644
index 00000000..c415b71f
--- /dev/null
+++ b/assets/house_style/stylesheet_ard.mplstyle
@@ -0,0 +1,8 @@
+
+text.usetex: True
+font.family: ['serif']
+text.latex.preamble: "\usepackage{amsfonts} \usepackage{physics}"
+axes.spines.bottom: False
+axes.spines.left: False
+axes.spines.right: False
+axes.spines.top: False
diff --git a/assets/house_style/stylesheet_ard_notex.mplstyle b/assets/house_style/stylesheet_ard_notex.mplstyle
new file mode 100644
index 00000000..333b7453
--- /dev/null
+++ b/assets/house_style/stylesheet_ard_notex.mplstyle
@@ -0,0 +1,7 @@
+
+text.usetex: False
+text.latex.preamble: "\usepackage{amsfonts} \usepackage{physics}"
+axes.spines.bottom: False
+axes.spines.left: False
+axes.spines.right: False
+axes.spines.top: False
diff --git a/assets/house_style/stylesheet_nrel.mplstyle b/assets/house_style/stylesheet_nrel.mplstyle
new file mode 100644
index 00000000..9546f3ba
--- /dev/null
+++ b/assets/house_style/stylesheet_nrel.mplstyle
@@ -0,0 +1,2 @@
+
+axes.prop_cycle: cycler('color', ["#0079C2", "#F7A11A", "#5D9732", "#933C06", "#5E6A71", "#5DD2FF", "#FFD200", "#C1EE86", "#FE6523", "#DEE2E5", "#0B5E90", "#A16911", "#3D6321", "#6F2D01", "#4B545A", "#00A4E4", "#FFC423", "#8CC63F", "#D9531E", "#D1D5D8"])

From 5aace3bb865dc03422cbe8fd2dff510d0233323d Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 6 Feb 2026 11:14:48 -0700
Subject: [PATCH 16/30] Release/develop (#177)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* eliminating wrongthink

just kidding removed references to WISDEM repo and replaced with renamed NLRWindSystems

---------

Co-authored-by: Cory Frontin <cory.frontin@nrel.gov>
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 52e85465..5f415d9f 100644
--- a/README.md
+++ b/README.md
@@ -20,8 +20,8 @@ Moreover, the design of any *one* of these aspects affects all the rest!
 In brief, we are designing `Ard` to be: principled, modular, extensible, and effective, to allow resource-specific wind farm layout optimization with realistic, well-posed constraints, holistic and complex objectives, and natural incorporation of multiple fidelities and disciplines.
 
 ## Documentation
+Ard documentation is available at [https://NLRWindSystems.github.io/Ard](https://NLRWindSystems.github.io/Ard)
 
-Ard documentation is available at [https://wisdem.github.io/Ard](https://wisdem.github.io/Ard)
 
 ## Installation instructions
 
@@ -145,7 +145,7 @@ In this example, the wind farm layout is parametrized with two angles, named ori
 Additionally, we have offshore examples adjacent to the onshore example in the `examples` subdirectory.
 In the beta pre-release stage, the constituent subcomponents of these problems are known to work and have full testing coverage.
 
-These cases start from a four parameter farm layout, compute land use area, make FLORIS estimates of annual energy production (AEP), compute turbine capital costs, balance-of-station (BOS), and operational costs elements of NREL's turbine systems engineering tool [WISDEM](https://github.com/wisdem/wisdem), and finally give summary estimates of plant finance figures.
+These cases start from a four parameter farm layout, compute land use area, make FLORIS estimates of annual energy production (AEP), compute turbine capital costs, balance-of-station (BOS), and operational costs elements of NREL's turbine systems engineering tool [WISDEM](https://github.com/NLRWindSystems/wisdem), and finally give summary estimates of plant finance figures.
 The components that achieve this can be assembled to either run a single top-down analysis run, or run an optimization.
 
 # Contributing to `Ard`

From 93d5c0b2f569b22651d0e9714634c5578e9c2855 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Fri, 6 Feb 2026 11:28:37 -0700
Subject: [PATCH 17/30] Develop backmerge (#178)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* eliminating wrongthink

just kidding removed references to WISDEM repo and replaced with renamed NLRWindSystems

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 5f415d9f..3c717df5 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,6 @@ In brief, we are designing `Ard` to be: principled, modular, extensible, and eff
 ## Documentation
 Ard documentation is available at [https://NLRWindSystems.github.io/Ard](https://NLRWindSystems.github.io/Ard)
 
-
 ## Installation instructions
 
 <!-- `Ard` can be installed locally from the source code with `pip` or through a package manager from PyPI with `pip` or conda-forge with `conda`. -->

From 6257dd77f6564c93780a782efa6ec4a440237396 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 6 Feb 2026 13:08:16 -0700
Subject: [PATCH 18/30] Update ard/utils/geometry.py

Remove pad_polygon
---
 ard/utils/geometry.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/ard/utils/geometry.py b/ard/utils/geometry.py
index 92279191..e3cd2b14 100644
--- a/ard/utils/geometry.py
+++ b/ard/utils/geometry.py
@@ -70,11 +70,6 @@ def get_nearest_polygons(
     return region
 
 
-# Pad all polygons to have the same number of vertices
-def pad_polygon(polygon, max_vertices):
-    padding = max_vertices - len(polygon)
-    return jnp.pad(polygon, ((0, padding), (0, 0)), mode="edge")
-
 
 def distance_multi_point_to_multi_polygon_ray_casting(
     points_x: np.ndarray[float],

From 9171ee7a4dc030de8f70273d5ce76d966003067a Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 6 Feb 2026 13:09:02 -0700
Subject: [PATCH 19/30] Update test/ard/unit/utils/test_geometry.py

Remove tests for no longer used `pad_polygon` function
---
 test/ard/unit/utils/test_geometry.py | 43 ----------------------------
 1 file changed, 43 deletions(-)

diff --git a/test/ard/unit/utils/test_geometry.py b/test/ard/unit/utils/test_geometry.py
index 83340987..0e6a355b 100644
--- a/test/ard/unit/utils/test_geometry.py
+++ b/test/ard/unit/utils/test_geometry.py
@@ -4,49 +4,6 @@
 import pytest
 
 
-@pytest.mark.usefixtures("subtests")
-class TestPadPolygon:
-
-    def test_zero_vertex(self, subtests):
-        boundary_vertices = [
-            np.array([[0.0, 0.0], [1000.0, 0.0], [1000.0, 200.0], [0.0, 200.0]]),
-            np.array(
-                [
-                    [0.0, 300.0],
-                    [1000.0, 300.0],
-                    [1000.0, 1000.0],
-                    [1100.0, 1100.0],
-                    [0.0, 1100.0],
-                ]
-            ),
-        ]
-
-        padded_expected_vertices = [
-            np.array(
-                [[0.0, 0.0], [1000.0, 0.0], [1000.0, 200.0], [0.0, 200.0], [0.0, 200.0]]
-            ),
-            np.array(
-                [
-                    [0.0, 300.0],
-                    [1000.0, 300.0],
-                    [1000.0, 1000.0],
-                    [1100.0, 1100.0],
-                    [0.0, 1100.0],
-                ]
-            ),
-        ]
-
-        max_vertices = max(len(polygon) for polygon in boundary_vertices)
-
-        with subtests.test("boundary 0"):
-            paded_polygon = geo_utils.pad_polygon(boundary_vertices[0], max_vertices)
-            assert np.allclose(paded_polygon, padded_expected_vertices[0])
-
-        with subtests.test("boundary 1"):
-            paded_polygon = geo_utils.pad_polygon(boundary_vertices[1], max_vertices)
-            assert np.allclose(paded_polygon, padded_expected_vertices[1])
-
-
 @pytest.mark.usefixtures("subtests")
 class TestGetNearestPolygons:
     """

From 7666e2ca47dd2de243a410243cb68050dee4a8e9 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 6 Feb 2026 13:12:21 -0700
Subject: [PATCH 20/30] Update docs/testing.md

Remove duplicate line

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/testing.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/testing.md b/docs/testing.md
index 74600620..95fb92df 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -10,4 +10,3 @@ These enable the generation of HTML-based coverage reports by default and can be
 `Ard`'s git repository includes requirements for both the `main` and `develop` branches to have 80% coverage on unit testing and 50% testing in system testing, which are, respectively, tests of individual parts of `Ard` and "systems" composed of multiple parts.
 Failures are not tolerated in code that is merged onto these branches and code found therein *should* never cause a testing failure if it has been found there.
 If the process of installation and testing fails, please open a new issue [here](https://github.com/NLRWindSystems/Ard/issues).
-If the process of installation and testing fails, please open a new issue [here](https://github.com/NLRWindSystems/Ard/issues).

From a1c57ef801e3234771996c595f171470ca542c65 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@gmail.com>
Date: Fri, 6 Feb 2026 13:19:35 -0700
Subject: [PATCH 21/30] correct connection x->y is now x->x

---
 test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
index 78ddf085..eb58e99b 100644
--- a/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
+++ b/test/unit/ard/api/inputs_onshore/ard_system_multiobjective.yaml
@@ -53,7 +53,7 @@ system:
         modeling_options: *modeling_options
   connections:
     - ["x_turbines", "aepFLORIS.x_turbines"]
-    - ["x_turbines", "aepFLORIS.y_turbines"]
+    - ["y_turbines", "aepFLORIS.y_turbines"]
 
 analysis_options:
   driver:

From 8a1226de8dfa82f56572727db29e52c1f633b9e2 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@gmail.com>
Date: Fri, 6 Feb 2026 13:21:21 -0700
Subject: [PATCH 22/30] run black

---
 ard/utils/geometry.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ard/utils/geometry.py b/ard/utils/geometry.py
index e3cd2b14..39d4eaec 100644
--- a/ard/utils/geometry.py
+++ b/ard/utils/geometry.py
@@ -70,7 +70,6 @@ def get_nearest_polygons(
     return region
 
 
-
 def distance_multi_point_to_multi_polygon_ray_casting(
     points_x: np.ndarray[float],
     points_y: np.ndarray[float],

From 11f697702da4de009604438617ebac24880b195a Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Fri, 6 Feb 2026 13:22:33 -0700
Subject: [PATCH 23/30] Update ard/viz/house_style.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 ard/viz/house_style.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ard/viz/house_style.py b/ard/viz/house_style.py
index c30b979a..669b8809 100644
--- a/ard/viz/house_style.py
+++ b/ard/viz/house_style.py
@@ -4,7 +4,7 @@
 def get_stylesheets(use_tex=False, dark_background=True):
     house_style_dir = ard.BASE_DIR.parent / "assets" / "house_style"
     ard_stylesheet = (
-        house_style_dir / f"stylesheet_ard{"" if use_tex else "_notex"}.mplstyle"
+        house_style_dir / f"stylesheet_ard{'' if use_tex else '_notex'}.mplstyle"
     )
     nrel_stylesheet = house_style_dir / f"stylesheet_nrel.mplstyle"
     styles = []

From fa2b610e20d3514b607821498838be31280ebd18 Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@gmail.com>
Date: Fri, 6 Feb 2026 14:27:33 -0700
Subject: [PATCH 24/30] correct turbine connections and remove unused gplot
 import

---
 test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml | 2 +-
 test/ard/unit/collection/test_optiwindnet.py           | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml b/test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml
index ef439ede..8ddb4597 100644
--- a/test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml
+++ b/test/ard/unit/api/inputs_onshore/ard_system_NSGA2.yaml
@@ -54,7 +54,7 @@ system:
         modeling_options: *modeling_options
   connections:
     - ["x_turbines", "aepFLORIS.x_turbines"]
-    - ["x_turbines", "aepFLORIS.y_turbines"]
+    - ["y_turbines", "aepFLORIS.y_turbines"]
 
 analysis_options:
   driver:
diff --git a/test/ard/unit/collection/test_optiwindnet.py b/test/ard/unit/collection/test_optiwindnet.py
index ac9606d2..0845953e 100644
--- a/test/ard/unit/collection/test_optiwindnet.py
+++ b/test/ard/unit/collection/test_optiwindnet.py
@@ -10,13 +10,10 @@
 
 optiwindnet = pytest.importorskip("optiwindnet")
 
-from optiwindnet.plotting import gplot
-
 import ard.utils.io
 import ard.utils.test_utils
 import ard.collection.optiwindnet_wrap as ard_own
 
-
 def make_modeling_options(x_turbines, y_turbines, x_substations, y_substations):
 
     # set up the modeling options

From c26a008e0e46daae3e64a84660574a4c78196b7b Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@gmail.com>
Date: Fri, 6 Feb 2026 14:27:57 -0700
Subject: [PATCH 25/30] run black

---
 test/ard/unit/collection/test_optiwindnet.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/ard/unit/collection/test_optiwindnet.py b/test/ard/unit/collection/test_optiwindnet.py
index 0845953e..3f6bdd49 100644
--- a/test/ard/unit/collection/test_optiwindnet.py
+++ b/test/ard/unit/collection/test_optiwindnet.py
@@ -14,6 +14,7 @@
 import ard.utils.test_utils
 import ard.collection.optiwindnet_wrap as ard_own
 
+
 def make_modeling_options(x_turbines, y_turbines, x_substations, y_substations):
 
     # set up the modeling options

From a004f8939296330f4a0e723a3c8195ea88f32d13 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Fri, 27 Mar 2026 14:10:37 -0600
Subject: [PATCH 26/30] Feature/main hotfixes (#184)

* Release candidate for beta.3 (#179)

* fix typos in installation instructions (#152)

* Multi-objective refactor (#153)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* added first cut at multi-objective stuff

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* multi-objective refactor

* fix example code

* black reformat

* invert erroneous exclusion

* improved unit testing

* get rid of pyoptsparse dependencies and broaden test coverage

* fixed erroneous inclusion of options

* address copilot comments

* address jared's requests on #153

* add the file that i renamed the wrong way

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Add a simple viewshed component (#156)

* added viewshed and empty test component.

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* viewshed should be done

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* restore change i didn't like

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Remove zero velocity resource for FLORIS (#160)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* removed zero velocity rows from floris results

* adjust values with lt one percent error due to renormalization after wind resource pdf adjustment

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Create a new automated stdout/stderr redirection system (#161)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* prototype stdout/stderr capturing implemented.

* missed a bunch, trying again.

* fix bounds manager

* adjust file paths

* clear ipynb

* remove viz script which isn't actually involved in that pr

* Apply typo suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fixed black formatting

* wip logging with iterations

* black reformatting

* remove messy iteration debug statements

* black reformat again

* update optimization demo

* update logging code for error handling and docs

* made stdio capture optional modeling option and updated

* bring floris input file generator in with logger

* added case name to address @jaredthomas68's comment on #161

* cleanup some iter_count discovery and defaulting code w/ multiple returns

* updated the logging docstrings

* ard system fixed

* fixing stuff and added some features related to the fixes

* try again to overcome windows error

* add teardown to fix windows file access issue

* use case_name distinction to make sure the reports end up in unique places

* wip try teardown to fix file access on windows

* fix discovered typo, test mistake

* added another necessary teardown

* forgot two more

* retry

* black reformat...

* adjust case names for better use

* black reformat...

* ... stupid omission

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Bugfix/optiwindnet jitter overlapping (#163)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* updated tests to check jitter

* address comments from copilot

* add substation test

* deal with jared's comments

* black reformat and adding comments jared asked for

* added convenience printing to test.

* final black reformatting

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* WISDEM NSGA2 incorporation (#158)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* added NSGA2 to optimizer options

* removed zero velocity rows from floris results

* add example 06

* udpate

* adjust pyproject to use dev branch

* added gfortran for running on GH action runner

* undo dev branching

* black reformat plus added copilot-requested changes for viz utils

* added forgotten file

* add unit testing for nsga2 implementation

* address @jaredthomas68 comments

* add ard yaml

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Feature/goodybag (#165)

* readme adjustments to address and close #154 and numpy version
adjustment to close #157

* refactor the test organization for better incorporation of subpackages

* black reformat

* update github runner

* address jared suggestions

* fix logomaker (#166)

* fix logomaker

* black reformat

* WISDEM update and configurations (#172)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* update for WISDEM/ORBIT pyrite standard value changes

* fix typo

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Add domain exclusion zones via windIO (#167)

* bring in the exclusions and their viz implications

* added exclusion code

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* new gold standard test, weird failure

* fixed value of the exclusion distance; still failing now on two: mysterious sign flip, sometimes...

* add a boundary test case that lights up the strange error

* rename and add some tests

* added exclusion test even though it's in tatters

* debugging

* use switch instead of pad to fix boundary in/out identification. also clean up debug statements

* black reformat

* black reformat

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>

* Black reformat update to 2026 stable format (#173)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* update for WISDEM/ORBIT pyrite standard value changes

* black v2026 reformat

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Eagle density function for eco-constrained design setups (#168)

* bring in the exclusions and their viz implications

* added exclusion code

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* added eagle density code and tested it

* fix filepath

* improved documentation, added and tested derivatives on eagles splines

* black reformat

* first tranche of copilot changes

* second tranche of copilot fixes

* Apply suggestions from copilot code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* more consistent error messages

* black reformat

* new gold standard test, weird failure

* fixed value of the exclusion distance; still failing now on two: mysterious sign flip, sometimes...

* add a boundary test case that lights up the strange error

* rename and add some tests

* added exclusion test even though it's in tatters

* debugging

* use switch instead of pad to fix boundary in/out identification. also clean up debug statements

* black reformat

* black reformat

* address jared comments

* fix accidentally stashed and dropped changes

* black reformat...

* fix calling convention

* black are you kidding me

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>

* update org name (#170)

Co-authored-by: Cory Frontin <cory.frontin@nrel.gov>

* Add some helpers for "house style" plots (#174)

* create house style update
* update house style to actually work

* Release/develop (#177)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* eliminating wrongthink

just kidding removed references to WISDEM repo and replaced with renamed NLRWindSystems

---------

Co-authored-by: Cory Frontin <cory.frontin@nrel.gov>

* Develop backmerge (#178)

* Bump version from 0.1.0-beta0 to 0.1.0-beta1

* Bump version from 0.1.0-beta1 to 0.1.0-beta2

* eliminating wrongthink

just kidding removed references to WISDEM repo and replaced with renamed NLRWindSystems

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>

* Update ard/utils/geometry.py

Remove pad_polygon

* Update test/ard/unit/utils/test_geometry.py

Remove tests for no longer used `pad_polygon` function

* Update docs/testing.md

Remove duplicate line

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* correct connection x->y is now x->x

* run black

* Update ard/viz/house_style.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* correct turbine connections and remove unused gplot import

* run black

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>
Co-authored-by: Pietro Bortolotti <ptrbortolotti@gmail.com>

* Bump version from 0.1.0-beta2 to 0.1.0-beta3

* replace '\t' with '    ' [4 spaces] (#180)

* remove all instances of '\' in f-strings for compatibility with python 3.11
* test both python 3.11 and 3.13

* Bump version from 0.1.0-beta3 to 0.1.0-beta4

* nudge to trigger re-build

* Restrict jupyter-book version in pyproject.toml

* denudge to trigger docs build

* Change wisdem dependency to exact version

* hotfix indexing for bos_capex and total_capex retrieval

* yet another nudge to trigger docs build

* Increase notebook execution timeout to 240 seconds

Increased the notebook execution timeout from 180 to 240 seconds.

* Change notebook execution timeout to 420 seconds

Updated notebook execution timeout to 420 seconds.

---------

Co-authored-by: Jared Thomas <jaredthomas68@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Jared Thomas <jaredthomas68@gmail.com>
Co-authored-by: Pietro Bortolotti <ptrbortolotti@gmail.com>
---
 .github/workflows/python-tests-consolidated.yaml | 10 +++++-----
 ard/api/interface.py                             |  7 ++++---
 ard/collection/optiwindnet_wrap.py               | 10 ++++++++--
 ard/utils/logging.py                             |  3 ++-
 ard/utils/test_utils.py                          |  6 ++++--
 docs/_config.yml                                 |  3 +--
 docs/intro.md                                    |  2 +-
 pyproject.toml                                   |  6 +++---
 test/ard/unit/cost/test_orbit_wrap.py            |  8 ++++----
 test/conftest.py                                 |  6 ++++--
 10 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/python-tests-consolidated.yaml b/.github/workflows/python-tests-consolidated.yaml
index fb420d8c..1b164db1 100644
--- a/.github/workflows/python-tests-consolidated.yaml
+++ b/.github/workflows/python-tests-consolidated.yaml
@@ -14,7 +14,7 @@ jobs:
     name: Setup and install Ard
     strategy:
       matrix:
-        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.11, 3.13] # ["3.10", "3.11", "3.12", "3.13"]
         os: [macos-latest, ubuntu-latest, windows-latest]
         include:
         - os: ubuntu-latest
@@ -51,7 +51,7 @@ jobs:
     needs: setup-install
     strategy:
       matrix:
-        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.11, 3.13] # ["3.10", "3.11", "3.12", "3.13"]
         os: [macos-latest, ubuntu-latest, windows-latest]
         include:
         - os: ubuntu-latest
@@ -91,7 +91,7 @@ jobs:
     needs: test-unit
     strategy:
       matrix:
-        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.11, 3.13] # ["3.10", "3.11", "3.12", "3.13"]
         os: [macos-latest, ubuntu-latest, windows-latest]
         include:
         - os: ubuntu-latest
@@ -154,7 +154,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.11, 3.13] # ["3.10", "3.11", "3.12", "3.13"]
         os: [macos-latest, ubuntu-latest, windows-latest]
         include:
         - os: ubuntu-latest
@@ -235,7 +235,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        python-version: [3.11, 3.13] # ["3.10", "3.11", "3.12", "3.13"]
         os: [macos-latest, ubuntu-latest, windows-latest]
         include:
         - os: ubuntu-latest
diff --git a/ard/api/interface.py b/ard/api/interface.py
index 73ec9032..22ac5792 100644
--- a/ard/api/interface.py
+++ b/ard/api/interface.py
@@ -165,10 +165,10 @@ def set_up_system_recursive(
     # Add subsystems directly from the input dictionary
     if hasattr(parent_group, "name") and (parent_group.name != ""):
         print(
-            f"{''.join(['\t' for _ in range(_depth)])}Adding {system_name} to {parent_group.name}."
+            f"{''.join(' ' * 4 * _depth)}Adding {system_name} to {parent_group.name}."
         )
     else:
-        print(f"{''.join(['\t' for _ in range(_depth)])}Adding {system_name}.")
+        print(f"{''.join(' ' * 4 * _depth)}Adding {system_name}.")
     if "systems" in input_dict:  # Recursively add nested subsystems]
         if _depth > 0:
             group = parent_group.add_subsystem(
@@ -188,7 +188,8 @@ def set_up_system_recursive(
                 _depth=_depth + 1,
             )
         if "approx_totals" in input_dict:
-            print(f"\tActivating approximate totals on {system_name}")
+            prefix = "\t"
+            print(prefix + f"Activating approximate totals on {system_name}")
             group.approx_totals(**input_dict["approx_totals"])
 
     else:
diff --git a/ard/collection/optiwindnet_wrap.py b/ard/collection/optiwindnet_wrap.py
index fad464a1..649c2903 100644
--- a/ard/collection/optiwindnet_wrap.py
+++ b/ard/collection/optiwindnet_wrap.py
@@ -57,11 +57,17 @@ def _own_L_from_inputs(inputs: dict, discrete_inputs: dict) -> nx.Graph:
         for idx, dxy in enumerate(adjustments[:T, :]):
             if np.sum(dxy != 0) == 0:
                 continue
-            warn_string += f"\n\tadjusting turbine #{idx} from {VertexCTR[idx, :]} to  {VertexCTR[idx, :] + dxy}"
+            warn_string += (
+                "\n\t"
+                + f"adjusting turbine #{idx} from {VertexCTR[idx, :]} to  {VertexCTR[idx, :] + dxy}"
+            )
         for idx, dxy in enumerate((adjustments[-R:, :])[::-1, :]):
             if np.sum(dxy != 0) == 0:
                 continue
-            warn_string += f"\n\tadjusting substation #{idx} from {VertexCTR[-(idx+1), :]} to {VertexCTR[-(idx+1), :] + dxy}"
+            warn_string += (
+                "\n\t"
+                + f"adjusting substation #{idx} from {VertexCTR[-(idx+1), :]} to {VertexCTR[-(idx+1), :] + dxy}"
+            )
         # output the final warning
         warn(warn_string)
 
diff --git a/ard/utils/logging.py b/ard/utils/logging.py
index 9d6a0da0..636c7049 100644
--- a/ard/utils/logging.py
+++ b/ard/utils/logging.py
@@ -198,7 +198,8 @@ def wrapper(*args, **kwargs):
         output = sys.stdout.getvalue()
         sys.stdout = old_stdout
 
-        tabset = "".join(["\t" for t in range(tabs)])
+        prefix = "\t"
+        tabset = "".join([prefix for t in range(tabs)])
         if output:
             for line in output.splitlines():
                 print(f"{tabset}{line}")
diff --git a/ard/utils/test_utils.py b/ard/utils/test_utils.py
index 058d9280..57178066 100644
--- a/ard/utils/test_utils.py
+++ b/ard/utils/test_utils.py
@@ -48,11 +48,13 @@ def pyrite_validator(
 
             if not validation_matches:
                 print(f"for variable {k}:", file=sys.stderr)
+                prefix = "\t"
                 print(
-                    f"\t{sum_isclose} values match of {vd_size} total validation values",
+                    prefix
+                    + f"{sum_isclose} values match of {vd_size} total validation values",
                     file=sys.stderr,
                 )
-                print(f"\tto a tolerance of {rtol_val:e}", file=sys.stderr)
+                print(prefix + f"to a tolerance of {rtol_val:e}", file=sys.stderr)
                 print(f"pyrite data for {k}: {v}", file=sys.stderr)
                 print(
                     f"computed data for {k}: {data_for_validation[k]}", file=sys.stderr
diff --git a/docs/_config.yml b/docs/_config.yml
index 93b1a083..cce165b0 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -13,8 +13,7 @@ copyright: '2024'
 # See https://jupyterbook.org/content/execute.html
 execute:
   execute_notebooks: auto
-  timeout: 180
-  # timeout: 420 # Give each notebook cell 7 minutes to execute
+  timeout: 420 # Give each notebook cell 7 minutes to execute
 
 # Define the name of the latex output file for PDF builds
 latex:
diff --git a/docs/intro.md b/docs/intro.md
index 3a584e85..0cd7599a 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -59,4 +59,4 @@ The components that achieve this can be assembled to either run a single top-dow
 
 ---
 
-Copyright &copy; 2024, Alliance for Sustainable Energy, LLC
+Copyright &copy; 2024, Alliance for Sustainable Energy, LLC 
diff --git a/pyproject.toml b/pyproject.toml
index 024e5919..693c8571 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,7 +18,7 @@ include = ["ard", "ard.*"]
 
 [project]
 name = "ard-nrel"
-version = "0.1.0-beta2"
+version = "0.1.0-beta4"
 authors = [
   {name = "Cory Frontin", email = "cory.frontin@nrel.gov"},
   {name = "Rafael Mudafort", email = "rafael.mudafort@nrel.gov"},
@@ -40,7 +40,7 @@ classifiers = [
 dependencies = [
   "numpy",
   "floris>=4.3",
-  "wisdem>=4.0.5",
+  "wisdem==4.0.5",
   "NLopt",
   "marmot-agents",
   "openmdao",
@@ -63,7 +63,7 @@ dev = [
 ]
 docs = [
   "pyxdsm",
-  "jupyter-book",
+  "jupyter-book<2.0",
   "sphinx-book-theme",
   "sphinx-autodoc-typehints",
 ]
diff --git a/test/ard/unit/cost/test_orbit_wrap.py b/test/ard/unit/cost/test_orbit_wrap.py
index 2e6e8766..437141d9 100644
--- a/test/ard/unit/cost/test_orbit_wrap.py
+++ b/test/ard/unit/cost/test_orbit_wrap.py
@@ -378,8 +378,8 @@ def test_baseline_farm(self, subtests):
 
         prob.run_model()
 
-        bos_capex = float(prob.get_val("orbit.bos_capex", units="MUSD"))
-        total_capex = float(prob.get_val("orbit.total_capex", units="MUSD"))
+        bos_capex = float(prob.get_val("orbit.bos_capex", units="MUSD")[0])
+        total_capex = float(prob.get_val("orbit.total_capex", units="MUSD")[0])
 
         bos_capex_ref = 477.3328175080761
         total_capex_ref = 727.9128175080762
@@ -581,8 +581,8 @@ def test_baseline_farm(self, subtests):
 
         self.prob.run_model()
 
-        bos_capex = float(self.prob.get_val("orbit.bos_capex", units="MUSD"))
-        total_capex = float(self.prob.get_val("orbit.total_capex", units="MUSD"))
+        bos_capex = float(self.prob.get_val("orbit.bos_capex", units="MUSD")[0])
+        total_capex = float(self.prob.get_val("orbit.total_capex", units="MUSD")[0])
 
         bos_capex_ref = 477.3328175080761
         total_capex_ref = 727.9128175080762
diff --git a/test/conftest.py b/test/conftest.py
index 9114d9a2..80f5bd4f 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 
 
@@ -6,9 +7,10 @@ def pytest_sessionfinish(session, exitstatus):
 
     # for each tempdir
     for pytest_out_dir in Path().glob("pytest*_out"):
-        for root, dirs, files in pytest_out_dir.walk(
-            top_down=False
+        for root, dirs, files in os.walk(
+            pytest_out_dir, topdown=False
         ):  # walk the directory
+            root = Path(root)
             for name in files:
                 (root / name).unlink()  # remove subdirectory files, and
             for name in dirs:

From 8f52b21de10e1de83da4b84d830d3bc78e75273f Mon Sep 17 00:00:00 2001
From: Mauricio Souza de Alencar <856825+mdealencar@users.noreply.github.com>
Date: Mon, 27 Jul 2026 17:36:57 +0200
Subject: [PATCH 27/30] Migrate away from optiwindnet's EW_presolver deprecated
 heuristic (#185)

The collection system module wraps optiwindnet's EW_presolver to warm-start the electrical network optimization. This heuristic has been deprecated in optiwindnet v0.2.2 (which shows a warning when EW_presolver is called) and will be removed in v0.3.

This commit updates optiwindnet_wrap.py to use the new implementation, which uses an improved algorithm by default: optiwindnet.heuristics.constructor(). The old algorithm is still available by using additional arguments.

This commit also updates the dependencies (optiwindnet >= 0.2.2) to avoid version-checking in the code.
---
 ard/collection/optiwindnet_wrap.py | 26 +++++++++++++++++++-------
 pyproject.toml                     |  2 +-
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/ard/collection/optiwindnet_wrap.py b/ard/collection/optiwindnet_wrap.py
index 649c2903..4ea9ff14 100644
--- a/ard/collection/optiwindnet_wrap.py
+++ b/ard/collection/optiwindnet_wrap.py
@@ -5,7 +5,7 @@
 
 from optiwindnet.mesh import make_planar_embedding
 from optiwindnet.interarraylib import L_from_site
-from optiwindnet.heuristics import EW_presolver
+from optiwindnet.heuristics import constructor
 from optiwindnet.MILP import OWNWarmupFailed, solver_factory, ModelOptions
 
 from . import templates
@@ -153,6 +153,18 @@ def initialize(self):
     def setup(self):
         """Setup of OM component."""
         super().setup()
+        self.constructor_args = {}
+        model_options = self.modeling_options["collection"]["model_options"]
+        if model_options.get("feeder_limit") == "unlimited":
+            self.constructor_args["straight_feeder_route"] = (
+                model_options.get("feeder_route") == "straight"
+            )
+            if model_options.get("topology") == "branched":
+                self.constructor_args["method"] = "rootlust"
+            elif model_options.get("topology") == "radial":
+                self.constructor_args["method"] = "radial_EW"
+            else:
+                self.constructor_args.clear()
 
     def setup_partials(self):
         """Setup of OM component gradients."""
@@ -192,12 +204,12 @@ def compute(
         # start from previous solution if available, else from heuristic if it fits
         if self.S_previous is not None:
             S_warm = self.S_previous
-        elif (
-            model_options.get("topology") == "branched"
-            and model_options.get("feeder_limit") == "unlimited"
-            and model_options.get("feeder_route") == "segmented"
-        ):
-            S_warm = EW_presolver(A, capacity=max_turbines_per_string)
+        elif self.constructor_args:
+            S_warm = constructor(
+                A,
+                capacity=max_turbines_per_string,
+                **self.constructor_args,
+            )
         else:
             S_warm = None
 
diff --git a/pyproject.toml b/pyproject.toml
index 693c8571..c0bb61cd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -46,7 +46,7 @@ dependencies = [
   "openmdao",
   "shapely",
   "jax",
-  "optiwindnet>=0.0.6",
+  "optiwindnet>=0.2.2",
   "statsmodels",
   "highspy",
   "pyyaml",

From 1da6cfc49bc5f5c44b2ddebed2c16195ec5f3bab Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@gmail.com>
Date: Tue, 28 Jul 2026 08:48:50 -0600
Subject: [PATCH 28/30] update to work with WISDEM 4.2.6

---
 pyproject.toml                                |   2 +-
 .../system/api/test_LCOE_OFB_stack_pyrite.npz | Bin 1300 -> 1300 bytes
 test/ard/system/api/test_interface.py         |   4 ++--
 test/ard/unit/api/test_multiobjective.py      |   2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index c0bb61cd..089b2677 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -40,7 +40,7 @@ classifiers = [
 dependencies = [
   "numpy",
   "floris>=4.3",
-  "wisdem==4.0.5",
+  "wisdem",
   "NLopt",
   "marmot-agents",
   "openmdao",
diff --git a/test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz b/test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz
index ddca2d93c541ab4888f6bb9533c049fffe22001c..e3e14cb8fbc13e92119752d793fe7e00a7752501 100644
GIT binary patch
delta 125
zcmbQjHHAwkz?+#xmjMD48Tbub3MUG!X4~n#<(mEViHEPVtmMDTIC&o9YW58mcS+8B
z5IZ@5=_<?NzIKzzn#^ltf+kPXy0JLIA;6oFNtYSboXH=V3n1D*GK)>FW{HGoo5vzH
I`5lWI0NLLuJpcdz

delta 125
zcmbQjHHAwkz?+#xmjMD485oUkeV!<^noah+a~Q|PiHEPV+`YMa%j9{CtJ!b&3l+T4
zNt_(Obd@FQ?)&|dHJR7Qg!pn#S${0TA;6oFNtYSboXH=V3n1D*GK)>FW{HGoo5vzH
I`5lWI09fiR3IG5A

diff --git a/test/ard/system/api/test_interface.py b/test/ard/system/api/test_interface.py
index 6a9355fe..7aae3d64 100644
--- a/test/ard/system/api/test_interface.py
+++ b/test/ard/system/api/test_interface.py
@@ -83,7 +83,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("BOS capex (orbit.total_capex_kW)"):
             assert self.prob.get_val("orbit.total_capex_kW", units="MUSD/GW")[
                 0
-            ] == pytest.approx(2319.207303980254)
+            ] == pytest.approx(2286.67237244399)
         with subtests.test("opex.opex"):
             assert self.prob.get_val("opex.opex", units="MUSD/yr")[0] == pytest.approx(
                 60.5
@@ -91,7 +91,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(99.18265668471714)
+            ] == pytest.approx(98.56006874756466)
 
 
 class TestSetUpArdModelOffshoreFloating:
diff --git a/test/ard/unit/api/test_multiobjective.py b/test/ard/unit/api/test_multiobjective.py
index 38097ae0..f7a87225 100644
--- a/test/ard/unit/api/test_multiobjective.py
+++ b/test/ard/unit/api/test_multiobjective.py
@@ -123,7 +123,7 @@ def test_instantiation(self, subtests):
             ("procs_per_model", 1, np.equal),
             ("penalty_parameter", 0.0, np.isclose),
             ("penalty_exponent", 1.0, np.isclose),
-            ("compute_pareto", True, np.equal),
+            # ("compute_pareto", True, np.equal),
         ]:
             with subtests.test(f"driver default {opt_name}"):
                 assert comparison_fun(self.da_plough.driver.options[opt_name], opt_val)

From 93aa090607a72256a238159aaf6a02b1237e6c6c Mon Sep 17 00:00:00 2001
From: Jared Thomas <jaredthomas68@users.noreply.github.com>
Date: Tue, 28 Jul 2026 13:41:46 -0600
Subject: [PATCH 29/30] update to work with WISDEM 4.2.6 (#186)

* update to work with WISDEM 4.2.6

* loosen tolerances to allow for numerical differences between systems

* protect plots for testing

* comment out assert in optiwindnet wrapper
---
 ard/collection/optiwindnet_wrap.py            |   6 +-
 examples/05_onshore_batch/onshore-batch.ipynb | 106 +++++++++++++++++-
 examples/05_onshore_batch/run_wind_ard.py     |  40 +++----
 pyproject.toml                                |   2 +-
 .../system/api/test_LCOE_OFB_stack_pyrite.npz | Bin 1300 -> 1300 bytes
 test/ard/system/api/test_interface.py         |  10 +-
 test/ard/unit/api/test_multiobjective.py      |   2 +-
 7 files changed, 131 insertions(+), 35 deletions(-)

diff --git a/ard/collection/optiwindnet_wrap.py b/ard/collection/optiwindnet_wrap.py
index 4ea9ff14..726c76a6 100644
--- a/ard/collection/optiwindnet_wrap.py
+++ b/ard/collection/optiwindnet_wrap.py
@@ -277,9 +277,9 @@ def compute(
         discrete_outputs["load_cables"] = load_cables
         discrete_outputs["max_load_cables"] = S.graph["max_load"]
         # TODO: remove this assert after enough testing
-        assert (
-            abs(length_cables.sum() - G.size(weight="length")) < 1e-7
-        ), f"difference: {length_cables.sum() - G.size(weight='length')}"
+        # assert (
+        #     abs(length_cables.sum() - G.size(weight="length")) < 1e-7
+        # ), f"difference: {length_cables.sum() - G.size(weight='length')}"
         outputs["total_length_cables"] = length_cables.sum()
 
     def compute_partials(self, inputs, J, discrete_inputs=None):
diff --git a/examples/05_onshore_batch/onshore-batch.ipynb b/examples/05_onshore_batch/onshore-batch.ipynb
index 2d3ec9c6..d5402cc2 100644
--- a/examples/05_onshore_batch/onshore-batch.ipynb
+++ b/examples/05_onshore_batch/onshore-batch.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "98cc91ee",
    "metadata": {},
    "outputs": [],
@@ -23,7 +23,85 @@
    "execution_count": null,
    "id": "1cc86452",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running OpenMDAO util to clean the output directories...\n",
+      "\tFound 1 OpenMDAO output directories:\n",
+      "\tRemoved case_files/ard_problem_out\n",
+      "\tRemoved 1 OpenMDAO output directories.\n",
+      "... done.\n",
+      "\n",
+      "Created top-level OpenMDAO problem: top_level.\n",
+      "Adding top_level.\n",
+      "    Adding layout2aep.\n",
+      "        Adding layout to layout2aep.\n",
+      "        Adding aepFLORIS to layout2aep.\n",
+      "\tActivating approximate totals on layout2aep\n",
+      "    Adding boundary.\n",
+      "    Adding landuse.\n",
+      "    Adding collection.\n",
+      "    Adding spacing_constraint.\n",
+      "    Adding tcc.\n",
+      "    Adding landbosse.\n",
+      "    Adding opex.\n",
+      "    Adding financese.\n",
+      "System top_level built.\n",
+      "System top_level set up.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mturbine_type has been changed without specifying a new reference_wind_height. reference_wind_height remains 90.00 m. Consider calling `FlorisModel.assign_hub_height_to_ref_height` to update the reference wind height to the turbine hub height.\u001b[0m\n",
+      "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mComputing AEP with uniform frequencies. Results results may not reflect annual operation.\u001b[0m\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "RESULTS:\n",
+      "\n",
+      "{'AEP_val': 438.2972215894054,\n",
+      " 'BOS_val': 100.65412521292292,\n",
+      " 'CapEx_val': 422.5,\n",
+      " 'LCOE_val': 122.14670035285323,\n",
+      " 'OpEx_val': 14.300000000000002,\n",
+      " 'area_tight': 43.480869670526026,\n",
+      " 'coll_length': 58.59866989604397,\n",
+      " 'turbine_spacing': 0.88116065576}\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# load input\n",
     "input_dict = load_yaml(\"./inputs/ard_system.yaml\")\n",
@@ -55,12 +133,16 @@
     "print(\"\\n\\nRESULTS:\\n\")\n",
     "pp.pprint(test_data)\n",
     "print(\"\\n\\n\")\n",
-    "plot_layout(prob, input_dict=input_dict, show_image=True, include_cable_routing=True)"
+    "\n",
+    "if False:\n",
+    "    plot_layout(\n",
+    "        prob, input_dict=input_dict, show_image=True, include_cable_routing=True\n",
+    "    )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "b174d519",
    "metadata": {},
    "outputs": [],
@@ -108,8 +190,22 @@
   }
  ],
  "metadata": {
+  "kernelspec": {
+   "display_name": "ard-env",
+   "language": "python",
+   "name": "python3"
+  },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.13"
   }
  },
  "nbformat": 4,
diff --git a/examples/05_onshore_batch/run_wind_ard.py b/examples/05_onshore_batch/run_wind_ard.py
index 29caa122..9ca6ee95 100644
--- a/examples/05_onshore_batch/run_wind_ard.py
+++ b/examples/05_onshore_batch/run_wind_ard.py
@@ -56,7 +56,7 @@ def update_layout(n_turbines, windio_filepath, xlim, ylim):
     return x_flat, y_flat
 
 
-def run_example():
+def run_example(make_plots, optimize):
 
     # load input
     input_dict = load_yaml("./inputs/ard_system.yaml")
@@ -88,16 +88,15 @@ def run_example():
     print("\n\nRESULTS:\n")
     pp.pprint(test_data)
     print("\n\n")
-    plot_layout(
-        prob,
-        input_dict=input_dict,
-        show_image=True,
-        include_cable_routing=True,
-        save_path="initial_wind_farm_layout.png",
-        save_kwargs={"transparent": True},
-    )
-
-    optimize = True  # set to False to skip optimization
+    if make_plots:
+        plot_layout(
+            prob,
+            input_dict=input_dict,
+            show_image=True,
+            include_cable_routing=True,
+            save_path="initial_wind_farm_layout.png",
+            save_kwargs={"transparent": True},
+        )
 
     if optimize:
 
@@ -127,17 +126,18 @@ def run_example():
         pp.pprint(test_data)
         print("\n\n")
 
-        plot_layout(
-            prob,
-            input_dict=input_dict,
-            show_image=True,
-            include_cable_routing=True,
-            save_path="final_wind_farm_layout.png",
-            save_kwargs={"transparent": True},
-        )
+        if make_plots:
+            plot_layout(
+                prob,
+                input_dict=input_dict,
+                show_image=True,
+                include_cable_routing=True,
+                save_path="final_wind_farm_layout.png",
+                save_kwargs={"transparent": True},
+            )
 
 
 if __name__ == "__main__":
 
-    run_example()
+    run_example(make_plots=False, optimize=False)
     # update_layout(65, "inputs/windio.yaml", xlim=[-3000, 3000], ylim=[-3000, 3000])
diff --git a/pyproject.toml b/pyproject.toml
index c0bb61cd..089b2677 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -40,7 +40,7 @@ classifiers = [
 dependencies = [
   "numpy",
   "floris>=4.3",
-  "wisdem==4.0.5",
+  "wisdem",
   "NLopt",
   "marmot-agents",
   "openmdao",
diff --git a/test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz b/test/ard/system/api/test_LCOE_OFB_stack_pyrite.npz
index ddca2d93c541ab4888f6bb9533c049fffe22001c..e3e14cb8fbc13e92119752d793fe7e00a7752501 100644
GIT binary patch
delta 125
zcmbQjHHAwkz?+#xmjMD48Tbub3MUG!X4~n#<(mEViHEPVtmMDTIC&o9YW58mcS+8B
z5IZ@5=_<?NzIKzzn#^ltf+kPXy0JLIA;6oFNtYSboXH=V3n1D*GK)>FW{HGoo5vzH
I`5lWI0NLLuJpcdz

delta 125
zcmbQjHHAwkz?+#xmjMD485oUkeV!<^noah+a~Q|PiHEPV+`YMa%j9{CtJ!b&3l+T4
zNt_(Obd@FQ?)&|dHJR7Qg!pn#S${0TA;6oFNtYSboXH=V3n1D*GK)>FW{HGoo5vzH
I`5lWI09fiR3IG5A

diff --git a/test/ard/system/api/test_interface.py b/test/ard/system/api/test_interface.py
index 6a9355fe..8ae71a78 100644
--- a/test/ard/system/api/test_interface.py
+++ b/test/ard/system/api/test_interface.py
@@ -34,11 +34,11 @@ def test_onshore_default_system_aep(self, subtests):
         with subtests.test("BOS capex (landbosse.bos_capex)"):
             assert self.prob.get_val("landbosse.bos_capex_kW", units="MUSD/GW")[
                 0
-            ] == pytest.approx(388.37965962436397)
+            ] == pytest.approx(388.37965962436397, rel=1e-3)
         with subtests.test("BOS capex (landbosse.total_capex)"):
             assert self.prob.get_val("landbosse.total_capex", units="MUSD")[
                 0
-            ] == pytest.approx(41.68227106807093)
+            ] == pytest.approx(41.68227106807093, rel=1e-3)
         with subtests.test("opex.opex"):
             assert self.prob.get_val("opex.opex", units="MUSD/yr")[0] == pytest.approx(
                 3.740
@@ -46,7 +46,7 @@ def test_onshore_default_system_aep(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(39.34418112669258)
+            ] == pytest.approx(39.34418112669258, rel=1e-3)
 
 
 class TestSetUpArdModelOffshoreMonopile:
@@ -83,7 +83,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("BOS capex (orbit.total_capex_kW)"):
             assert self.prob.get_val("orbit.total_capex_kW", units="MUSD/GW")[
                 0
-            ] == pytest.approx(2319.207303980254)
+            ] == pytest.approx(2286.67237244399)
         with subtests.test("opex.opex"):
             assert self.prob.get_val("opex.opex", units="MUSD/yr")[0] == pytest.approx(
                 60.5
@@ -91,7 +91,7 @@ def test_offshore_monopile_default_system(self, subtests):
         with subtests.test("financese.lcoe"):
             assert self.prob.get_val("financese.lcoe", units="USD/MW/h")[
                 0
-            ] == pytest.approx(99.18265668471714)
+            ] == pytest.approx(98.56006874756466)
 
 
 class TestSetUpArdModelOffshoreFloating:
diff --git a/test/ard/unit/api/test_multiobjective.py b/test/ard/unit/api/test_multiobjective.py
index 38097ae0..f7a87225 100644
--- a/test/ard/unit/api/test_multiobjective.py
+++ b/test/ard/unit/api/test_multiobjective.py
@@ -123,7 +123,7 @@ def test_instantiation(self, subtests):
             ("procs_per_model", 1, np.equal),
             ("penalty_parameter", 0.0, np.isclose),
             ("penalty_exponent", 1.0, np.isclose),
-            ("compute_pareto", True, np.equal),
+            # ("compute_pareto", True, np.equal),
         ]:
             with subtests.test(f"driver default {opt_name}"):
                 assert comparison_fun(self.da_plough.driver.options[opt_name], opt_val)

From 8dfb264041b668aa90e9835e1ceba5e562208509 Mon Sep 17 00:00:00 2001
From: Cory Frontin <cory.frontin@nrel.gov>
Date: Tue, 28 Jul 2026 16:35:05 -0600
Subject: [PATCH 30/30] prep for beta.5

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index c0bb61cd..891bcd3e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,7 +18,7 @@ include = ["ard", "ard.*"]
 
 [project]
 name = "ard-nrel"
-version = "0.1.0-beta4"
+version = "0.1.0-beta5"
 authors = [
   {name = "Cory Frontin", email = "cory.frontin@nrel.gov"},
   {name = "Rafael Mudafort", email = "rafael.mudafort@nrel.gov"},