Repository: NREL/floris

Issue:
ParallelFlorisModel updated to match FlorisModel API
# ParallelFlorisModel updated to match FlorisModel API

ParallelFlorisModel currently has an API not exactly 1-1 with FlorisModel.  This may be necessary, for example in order to defer certain calculations until splitting onto cores, however ideally the variance will be minimized as much as possible.  This issue is a placeholder to hold the intention to do some improvements in this vane and more generally.

## Proposed solution

- [x] Provide default values to max_workers and n_wind_condition_splits based on detection of available cores
- [x] Remove unsupported parallel computing interfaces, perhaps standardize on one?
- [x] Make sure all control vectors are supported, not just yaw
- [x] Remove no_wake flags in favor of run, run_no_wake style of v4
- [x] Match as close as possible FlorisModel interface


## Additional context
 A small subset of improvements was added in #967

Discussion:
@misi9170: Closed by #982 

Solution patch:
diff --git a/docs/_toc.yml b/docs/_toc.yml
index 4b78b0821..2dd0f99e1 100644
--- a/docs/_toc.yml
+++ b/docs/_toc.yml
@@ -12,8 +12,9 @@ parts:
   - caption: User Reference
     chapters:
     - file: intro_concepts
-    - file: advanced_concepts
     - file: wind_data_user
+    - file: floris_models
+    - file: advanced_concepts
     - file: heterogeneous_map
     - file: floating_wind_turbine
     - file: turbine_interaction
diff --git a/docs/advanced_concepts.ipynb b/docs/advanced_concepts.ipynb
index c13513c79..45fb9c017 100644
--- a/docs/advanced_concepts.ipynb
+++ b/docs/advanced_concepts.ipynb
@@ -9,7 +9,7 @@
     "# Advanced Concepts\n",
     "\n",
     "More information regarding the numerical and computational formulation in FLORIS\n",
-    "are detailed here. See [](concepts_intro) for a guide on the basics."
+    "are detailed here. See [Introductory Concepts](intro_concepts) for a guide on the basics."
    ]
   },
   {
diff --git a/docs/floris_models.ipynb b/docs/floris_models.ipynb
new file mode 100644
index 000000000..763014b7e
--- /dev/null
+++ b/docs/floris_models.ipynb
@@ -0,0 +1,390 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "(floris_models)=\n",
+    "\n",
+    "# FLORIS Models\n",
+    "\n",
+    "This notebook provides information on the provided FlorisModels. [Introductory Concepts](intro_concepts) introduced `FlorisModel` as the base class for all models in the FLORIS package. This notebook introduces the `ParFlorisModel`, `UncertainFlorisModel`, and `ApproxFlorisModel` classes, which are subclasses or compositions of `FlorisModel`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parallelized FLORIS Model\n",
+    "\n",
+    "The `ParFlorisModel` class is a subclass of `FlorisModel` that parallelizes the FLORIS calculations. This class is designed to \n",
+    "have an interface that is the same as `FlorisModel`, but the calculations are parallelized. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Instantiation\n",
+    "\n",
+    "The `ParFlorisModel` class can be instantiated in the same way as the `FlorisModel` class, or else it can be instantiated by passing a `FlorisModel` object to the constructor. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from floris import FlorisModel, ParFlorisModel, TimeSeries\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fmodel = FlorisModel(\"gch.yaml\")\n",
+    "\n",
+    "# Instantiation using yaml input file\n",
+    "pfmodel = ParFlorisModel(\"gch.yaml\")\n",
+    "\n",
+    "# Instantiation using fmodel\n",
+    "pfmodel = ParFlorisModel(fmodel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameters\n",
+    "\n",
+    "The `ParFlorisModel` class has additional parameters the define the parallelization. These parameters are:\n",
+    "\n",
+    "**interface**: The parallelization interface to use. Options are `\"multiprocessing\"`,\n",
+    "    `\"pathos\"`, and `\"concurrent\"`, with possible future support for `\"mpi4py\"`\n",
+    "\n",
+    "**max_workers**: The maximum number of workers to use. Defaults to -1, which then\n",
+    "    takes the number of CPUs available.\n",
+    "\n",
+    "**n_wind_condition_splits**: The number of wind conditions to split the simulation over.\n",
+    "    Defaults to the same as max_workers.\n",
+    "\n",
+    "**return_turbine_powers_only**: Whether to return only the turbine powers.\n",
+    "\n",
+    "**print_timings** (bool): Print the computation time to the console. Defaults to False."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Alternative parameters\n",
+    "pfmodel = ParFlorisModel(fmodel, max_workers=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Usage\n",
+    "\n",
+    "The `ParFlorisModel` class can be used in the same way as the `FlorisModel` class. The only difference is that the calculations are parallelized. \n",
+    "\n",
+    "```python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set to a two turbine layout\n",
+    "layout_x = [0, 500]\n",
+    "layout_y = [0, 0]\n",
+    "fmodel.set(layout_x=layout_x, layout_y=layout_y)\n",
+    "pfmodel.set(layout_x=layout_x, layout_y=layout_y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wind_directions = np.arange(240, 300, 0.5)\n",
+    "time_series = TimeSeries(\n",
+    "    wind_directions=wind_directions, wind_speeds=8.0, turbulence_intensities=0.06\n",
+    ")\n",
+    "fmodel.set(wind_data=time_series)\n",
+    "pfmodel.set(wind_data=time_series)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fmodel.run()\n",
+    "pfmodel.run()\n",
+    "\n",
+    "farm_power = fmodel.get_farm_power()\n",
+    "pfarm_power = pfmodel.get_farm_power()\n",
+    "\n",
+    "# Show the results are the same\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(wind_directions, farm_power, label=\"FlorisModel\", color='k', lw=5)\n",
+    "ax.plot(wind_directions, pfarm_power, label=\"ParFlorisModel\", color='r', ls='--', lw=2)\n",
+    "ax.set_xlabel(\"Wind Direction (deg)\")\n",
+    "ax.set_ylabel(\"Farm Power (kW)\")\n",
+    "ax.legend()\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## UncertainFlorisModel\n",
+    "\n",
+    "The `UncertainFlorisModel` class is a composition of `FlorisModel` that adds uncertainty to the input conditions.  Its interface is meant to made similar to `FlorisModel`, but with the addition of uncertainty in wind direction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Instantiation\n",
+    "\n",
+    "The `UncertainFlorisModel` class can be instantiated in the same way as the `FlorisModel` class, or else it can be instantiated by passing a `FlorisModel` object to the constructor.  Alternatively a `ParFlorisModel` object can be passed to the constructor which ensures the underlying calculations are parallelized according to the `ParFlorisModel` parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from floris import UncertainFlorisModel\n",
+    "\n",
+    "# Instantiation options\n",
+    "ufmodel = UncertainFlorisModel(\"gch.yaml\") # Using input yaml\n",
+    "ufmodel = UncertainFlorisModel(fmodel) # Using a FlorisModel object\n",
+    "ufmodel = UncertainFlorisModel(pfmodel) # Using a ParFlorisModel object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameters\n",
+    "\n",
+    "To include uncertainty into the wind direction, the `UncertainFlorisModel` class, for each findex run, the result for a wind direction is provided by performing a Gaussian blend over results from multiple wind directions nearby wind directions.  To reduce the total number of calculations required, a resolution of wind direction, wind speed, turbulence intensity and control inputs are specified and repeated calculations are only calculated once.  See the class API for complete details but some key parameters are:\n",
+    "\n",
+    "**wd_resolution, ws_resolution, ti_resolution, yaw_resolution, and power_setpoint_resolution**: Define the granularity of calculations for wind direction, wind speed, turbulence intensity, yaw angle, and power setpoints, respectively.\n",
+    "\n",
+    "**wd_std**: The standard deviation of wind direction, used in the Gaussian blending.\n",
+    "\n",
+    "**wd_sample_points**: Specific wind direction points to sample for expanded conditions.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the uncertainty to have a wd_std of 5 degrees and blend over 10 degrees\n",
+    "ufmodel = UncertainFlorisModel(fmodel, wd_std=5, wd_sample_points=[-5, -4, -3, -2, -1, 0, 1, 2,3, 4, 5], wd_resolution=0.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Usage\n",
+    "\n",
+    "Usage of `UncertainFlorisModel` is similar to `FlorisModel` however the results will now include the effects of Gaussian blending\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ufmodel.set(wind_data=time_series, layout_x=layout_x, layout_y=layout_y)\n",
+    "ufmodel.run()\n",
+    "\n",
+    "# Get the power of the downstream turbine\n",
+    "f_power = fmodel.get_turbine_powers()[:,1]\n",
+    "uf_power = ufmodel.get_turbine_powers()[:,1]\n",
+    "\n",
+    "# Plot the two powers\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(wind_directions, f_power, label=\"FlorisModel\", color='k', lw=5)\n",
+    "ax.plot(wind_directions, uf_power, label=\"UncertainFlorisModel\", color='r', lw=2)\n",
+    "ax.set_xlabel(\"Wind Direction (deg)\")\n",
+    "ax.set_ylabel(\"Turbine Power (kW)\")\n",
+    "ax.legend()\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ApproxFlorisModel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "   The ApproxFlorisModel overloads the UncertainFlorisModel with the special case that the `wd_sample_points = [0]`.  This is a special case where no uncertainty is added but the resolution of the values wind direction, wind speed etc are still reduced  by the specified resolution.  This allows for cases to be reused and a faster approximate result computed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Instantiation\n",
+    "\n",
+    "`ApproxFlorisModel` can be instantiated in the same way as the `UncertainFlorisModel` class"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from floris import ApproxFlorisModel\n",
+    "\n",
+    "# Instantiation options\n",
+    "amodel = ApproxFlorisModel(\"gch.yaml\") # Using input yaml\n",
+    "amodel = ApproxFlorisModel(fmodel) # Using a FlorisModel object\n",
+    "amodel = ApproxFlorisModel(pfmodel) # Using a ParFlorisModel object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Usage\n",
+    "\n",
+    "`ApproxFlorisModel` is used in the same way as `UncertainFlorisModel` but with the special case that the `wd_sample_points = [0]`. This means that while the resolution of the values `wind_direction`, `wind_speeds` etc are still reduced by the specified resolution, no uncertainty is added. It is intended for quickly processing large sets of inflow conditions (e.g., when reproducing SCADA records), when approximate solutions are sufficient.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate with a wind speed resolution of 0.5 m/s and a wind direction resolution of 1 degree\n",
+    "amodel = ApproxFlorisModel(fmodel, ws_resolution=0.5, wd_resolution=1.0) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "amodel has an n_findex of 40,  however, the number of unique cases to run at this resolution is 9.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Show approximation for a time series including smaller increments of wind speed\n",
+    "wind_speeds = np.arange(6, 10, 0.1)\n",
+    "time_series = TimeSeries(\n",
+    "    wind_directions = 270.0,\n",
+    "    wind_speeds=wind_speeds,\n",
+    "    turbulence_intensities=0.06\n",
+    ")\n",
+    "amodel.set(wind_data=time_series)\n",
+    "\n",
+    "print(f\"amodel has an n_findex of {amodel.n_findex}, \",\n",
+    "      f\"however, the number of unique cases to run at this resolution is {amodel.n_unique}.\")\n",
+    "\n",
+    "amodel.run()\n",
+    "farm_power = amodel.get_farm_power()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Show the farm power over wind speeds\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(wind_speeds, farm_power, label=\"ApproxFlorisModel\", color='k', lw=2)\n",
+    "ax.legend()\n",
+    "ax.set_xlabel(\"Wind Speed (m/s)\")\n",
+    "ax.set_ylabel(\"Farm Power (kW)\")\n",
+    "ax.grid()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "floris",
+   "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.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/intro_concepts.ipynb b/docs/intro_concepts.ipynb
index c72e8e0f0..60d8e96ea 100644
--- a/docs/intro_concepts.ipynb
+++ b/docs/intro_concepts.ipynb
@@ -5,7 +5,7 @@
    "id": "86e53920",
    "metadata": {},
    "source": [
-    "(concepts_intro)=\n",
+    "(intro_concepts)=\n",
     "# Introductory Concepts\n",
     "\n",
     "FLORIS is a Python-based software library for calculating wind farm performance considering\n",
diff --git a/examples/009_parallel_models.py b/examples/009_parallel_models.py
new file mode 100644
index 000000000..60f20762c
--- /dev/null
+++ b/examples/009_parallel_models.py
@@ -0,0 +1,95 @@
+"""Example 9: Parallel Models
+
+This example demonstrates how to use the ParFlorisModel class to parallelize the
+calculation of the FLORIS model. ParFlorisModel inherits from the FlorisModel
+and so can be used in the same way with a consistent interface. ParFlorisModel
+replaces the ParallelFlorisModel, which will be deprecated in a future release.
+
+"""
+
+import numpy as np
+
+from floris import (
+    FlorisModel,
+    ParFlorisModel,
+    TimeSeries,
+    UncertainFlorisModel,
+)
+
+
+# When using parallel optimization it is important the "root" script include this
+# if __name__ == "__main__": block to avoid problems
+if __name__ == "__main__":
+    # Instantiate the FlorisModel
+    fmodel = FlorisModel("inputs/gch.yaml")
+
+    # The ParFlorisModel can be instantiated either from a FlorisModel or from
+    # the input file.
+    pfmodel_1 = ParFlorisModel("inputs/gch.yaml")  # Via input file
+    pfmodel_2 = ParFlorisModel(fmodel)  # Via FlorisModel
+
+    # The ParFlorisModel has additional inputs which define the parallelization
+    # but don't affect the output.
+    pfmodel_3 = ParFlorisModel(
+        fmodel,
+        interface="multiprocessing",  # Default
+        max_workers=2,  # Defaults to num_cpu
+        n_wind_condition_splits=2,  # Defaults to max_workers
+    )
+
+    # Define a simple inflow
+    time_series = TimeSeries(
+        wind_speeds=np.arange(1, 25, 0.5), wind_directions=270.0, turbulence_intensities=0.06
+    )
+
+    # Demonstrate that interface and results are the same
+    fmodel.set(wind_data=time_series)
+    pfmodel_1.set(wind_data=time_series)
+    pfmodel_2.set(wind_data=time_series)
+    pfmodel_3.set(wind_data=time_series)
+
+    fmodel.run()
+    pfmodel_1.run()
+    pfmodel_2.run()
+    pfmodel_3.run()
+
+    # Compare the results
+    powers_fmodel = fmodel.get_turbine_powers()
+    powers_pfmodel_1 = pfmodel_1.get_turbine_powers()
+    powers_pfmodel_2 = pfmodel_2.get_turbine_powers()
+    powers_pfmodel_3 = pfmodel_3.get_turbine_powers()
+
+    print(
+        f"Testing if outputs of fmodel and pfmodel_1 are "
+        f"close: {np.allclose(powers_fmodel, powers_pfmodel_1)}"
+    )
+    print(
+        f"Testing if outputs of fmodel and pfmodel_2 are "
+        f"close: {np.allclose(powers_fmodel, powers_pfmodel_2)}"
+    )
+    print(
+        f"Testing if outputs of fmodel and pfmodel_3 are "
+        f"close: {np.allclose(powers_fmodel, powers_pfmodel_3)}"
+    )
+
+    # Because ParFlorisModel is a subclass of FlorisModel, it can also be used as
+    # an input to the UncertainFlorisModel class. This allows for parallelization of
+    # the uncertainty calculations.
+    ufmodel = UncertainFlorisModel(fmodel)
+    pufmodel = UncertainFlorisModel(pfmodel_1)
+
+    # Demonstrate matched results
+    ufmodel.set(wind_data=time_series)
+    pufmodel.set(wind_data=time_series)
+
+    ufmodel.run()
+    pufmodel.run()
+
+    powers_ufmodel = ufmodel.get_turbine_powers()
+    powers_pufmodel = pufmodel.get_turbine_powers()
+
+    print("--------------------")
+    print(
+        f"Testing if outputs of ufmodel and pufmodel are "
+        f"close: {np.allclose(powers_ufmodel, powers_pufmodel)}"
+    )
diff --git a/examples/009_compare_farm_power_with_neighbor.py b/examples/010_compare_farm_power_with_neighbor.py
similarity index 97%
rename from examples/009_compare_farm_power_with_neighbor.py
rename to examples/010_compare_farm_power_with_neighbor.py
index c67465f31..6ea23abd8 100644
--- a/examples/009_compare_farm_power_with_neighbor.py
+++ b/examples/010_compare_farm_power_with_neighbor.py
@@ -1,4 +1,4 @@
-"""Example 9: Compare farm power with neighboring farm
+"""Example 10: Compare farm power with neighboring farm
 
 This example demonstrates how to use turbine_weights to define a set of turbines belonging
 to a neighboring farm which impacts the power production of the farm under consideration
diff --git a/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py b/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py
index 17e02412b..d1688cb0e 100644
--- a/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py
+++ b/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py
@@ -16,14 +16,14 @@
 import numpy as np
 
 from floris import (
-    FlorisModel,
-    ParallelFlorisModel,
+    ParFlorisModel,
     TimeSeries,
     WindRose,
 )
+from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR
 
 
-# When using parallel optimization it is importat the "root" script include this
+# When using parallel optimization it is important the "root" script include this
 # if __name__ == "__main__": block to avoid problems
 if __name__ == "__main__":
 
@@ -33,19 +33,26 @@
         ti_col_or_value=0.06
     )
 
-    # Load FLORIS
-    fmodel = FlorisModel("../inputs/gch.yaml")
+    # Load FLORIS as a parallel model
+    max_workers = 16
+    pfmodel = ParFlorisModel(
+        "../inputs/gch.yaml",
+        max_workers=max_workers,
+        n_wind_condition_splits=max_workers,
+        interface="pathos",
+        print_timings=True,
+    )
 
     # Specify wind farm layout and update in the floris object
     N = 2  # number of turbines per row and per column
     X, Y = np.meshgrid(
-        5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1),
-        5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1),
+        5.0 * pfmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1),
+        5.0 * pfmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1),
     )
-    fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten())
+    pfmodel.set(layout_x=X.flatten(), layout_y=Y.flatten())
 
     # Get the number of turbines
-    n_turbines = len(fmodel.layout_x)
+    n_turbines = len(pfmodel.layout_x)
 
     # Optimize the yaw angles.  This could be done for every wind direction and wind speed
     # but in practice it is much faster to optimize only for one speed and infer the rest
@@ -53,46 +60,25 @@
     time_series = TimeSeries(
         wind_directions=wind_rose.wind_directions, wind_speeds=8.0, turbulence_intensities=0.06
     )
-    fmodel.set(wind_data=time_series)
-
-    # Set up the parallel model
-    parallel_interface = "concurrent"
-    max_workers = 16
-    pfmodel = ParallelFlorisModel(
-        fmodel=fmodel,
-        max_workers=max_workers,
-        n_wind_condition_splits=max_workers,
-        interface=parallel_interface,
-        print_timings=True,
-    )
+    pfmodel.set(wind_data=time_series)
 
-    # Get the optimal angles using the parallel interface
     start_time = timerpc()
-    # Now optimize the yaw angles using the Serial Refine method
-    df_opt = pfmodel.optimize_yaw_angles(
-        minimum_yaw_angle=0.0,
-        maximum_yaw_angle=20.0,
+    yaw_opt = YawOptimizationSR(
+        fmodel=pfmodel,
+        minimum_yaw_angle=0.0,  # Allowable yaw angles lower bound
+        maximum_yaw_angle=20.0,  # Allowable yaw angles upper bound
         Ny_passes=[5, 4],
-        exclude_downstream_turbines=False,
+        exclude_downstream_turbines=True,
     )
+    df_opt = yaw_opt.optimize()
     end_time = timerpc()
     t_tot = end_time - start_time
     print("Optimization finished in {:.2f} seconds.".format(t_tot))
 
-
     # Calculate the AEP in the baseline case, using the parallel interface
-    fmodel.set(wind_data=wind_rose)
-    pfmodel = ParallelFlorisModel(
-        fmodel=fmodel,
-        max_workers=max_workers,
-        n_wind_condition_splits=max_workers,
-        interface=parallel_interface,
-        print_timings=True,
-    )
-
-    # Note the pfmodel does not use run() but instead uses the get_farm_power() and get_farm_AEP()
-    # directly, this is necessary for the parallel interface
-    aep_baseline = pfmodel.get_farm_AEP(freq=wind_rose.unpack_freq())
+    pfmodel.set(wind_data=wind_rose)
+    pfmodel.run()
+    aep_baseline = pfmodel.get_farm_AEP()
 
     # Now need to apply the optimal yaw angles to the wind rose to get the optimized AEP
     # do this by applying a rule of thumb where the optimal yaw is applied between 6 and 12 m/s
@@ -102,9 +88,10 @@
     # yaw angles will need to be n_findex long, and accounting for the fact that some wind
     # directions and wind speeds may not be present in the wind rose (0 frequency) and aren't
     # included in the fmodel
-    wind_directions = fmodel.wind_directions
-    wind_speeds = fmodel.wind_speeds
-    n_findex = fmodel.n_findex
+    # TODO: add operation wind rose to example, once built
+    wind_directions = pfmodel.wind_directions
+    wind_speeds = pfmodel.wind_speeds
+    n_findex = pfmodel.n_findex
 
 
     # Now define how the optimal yaw angles for 8 m/s are applied over the other wind speeds
@@ -133,15 +120,9 @@
 
 
     # Now apply the optimal yaw angles and get the AEP
-    fmodel.set(yaw_angles=yaw_angles_wind_rose)
-    pfmodel = ParallelFlorisModel(
-        fmodel=fmodel,
-        max_workers=max_workers,
-        n_wind_condition_splits=max_workers,
-        interface=parallel_interface,
-        print_timings=True,
-    )
-    aep_opt = pfmodel.get_farm_AEP(freq=wind_rose.unpack_freq(), yaw_angles=yaw_angles_wind_rose)
+    pfmodel.set(yaw_angles=yaw_angles_wind_rose)
+    pfmodel.run()
+    aep_opt = pfmodel.get_farm_AEP()
     aep_uplift = 100.0 * (aep_opt / aep_baseline - 1)
 
     print("Baseline AEP: {:.2f} GWh.".format(aep_baseline/1E9))
diff --git a/examples/examples_uncertain/003_uncertain_model_with_parallelization.py b/examples/examples_uncertain/003_uncertain_model_with_parallelization.py
new file mode 100644
index 000000000..37f785c77
--- /dev/null
+++ b/examples/examples_uncertain/003_uncertain_model_with_parallelization.py
@@ -0,0 +1,85 @@
+"""Example: Uncertain Model With Parallelization
+
+This example demonstrates how to combined the parallelized model with the uncertain model
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from floris import (
+    FlorisModel,
+    TimeSeries,
+    UncertainFlorisModel,
+)
+from floris.par_floris_model import ParFlorisModel
+
+
+# Following the refactoring of ParFlorisModel, the UncertainFlorisModel can be
+# parallelized by passing the ParFlorisModel as the model to be run.  This example
+# demonstrates the usage and shows that the result obtained from the UncertainFlorisModel
+# with and without parallelization is the same.  The results are compared to the nominal
+# results.
+
+# Instantiate a FlorisModel and ParallelFlorisModel using the GCH model
+fmodel = FlorisModel("../inputs/gch.yaml")
+pfmodel = ParFlorisModel("../inputs/gch.yaml")
+
+# Use the above model to declare a serial and parallel UncertainFlorisModel
+ufmodel = UncertainFlorisModel(fmodel)
+pufmodel = UncertainFlorisModel(pfmodel)
+
+
+# Define an inflow where wind direction is swept while
+# wind speed and turbulence intensity are held constant
+wind_directions = np.arange(240.0, 300.0, 1.0)
+time_series = TimeSeries(
+    wind_directions=wind_directions,
+    wind_speeds=8.0,
+    turbulence_intensities=0.06,
+)
+
+# Define a two turbine farm and apply the inflow
+D = 126.0
+layout_x = np.array([0, D * 6])
+layout_y = [0, 0]
+
+# Apply to fmodel, ufmodel, and pufmodel
+fmodel.set(
+    layout_x=layout_x,
+    layout_y=layout_y,
+    wind_data=time_series,
+)
+
+ufmodel.set(
+    layout_x=layout_x,
+    layout_y=layout_y,
+    wind_data=time_series,
+)
+
+pufmodel.set(
+    layout_x=layout_x,
+    layout_y=layout_y,
+    wind_data=time_series,
+)
+
+# Run the models
+fmodel.run()
+ufmodel.run()
+pufmodel.run()
+
+# Collect the farm power results from each model
+farm_powers_nom = fmodel.get_farm_power() / 1e3
+farm_powers_unc = ufmodel.get_farm_power() / 1e3
+farm_powers_punc = pufmodel.get_farm_power() / 1e3
+
+# Compare the results
+fig, ax = plt.subplots()
+ax.plot(wind_directions, farm_powers_nom.flatten(), 'k-', label="Nominal power")
+ax.plot(wind_directions, farm_powers_unc.flatten(), 'bs-', label="Uncertain power")
+ax.plot(wind_directions, farm_powers_punc.flatten(), 'r.--', label="Parallel uncertain power")
+ax.grid(True)
+ax.legend()
+ax.set_xlabel("Wind Direction (deg)")
+ax.set_ylabel("Power (kW)")
+
+plt.show()
diff --git a/floris/__init__.py b/floris/__init__.py
index fd8ca5ddf..d97bb24eb 100644
--- a/floris/__init__.py
+++ b/floris/__init__.py
@@ -13,6 +13,7 @@
     visualize_quiver,
 )
 from .heterogeneous_map import HeterogeneousMap
+from .par_floris_model import ParFlorisModel
 from .parallel_floris_model import ParallelFlorisModel
 from .uncertain_floris_model import ApproxFlorisModel, UncertainFlorisModel
 from .wind_data import (
diff --git a/floris/floris_model.py b/floris/floris_model.py
index 10f410225..0967bd45c 100644
--- a/floris/floris_model.py
+++ b/floris/floris_model.py
@@ -619,8 +619,8 @@ def _get_weighted_turbine_powers(
         # Confirm run() has been run
         if self.core.state is not State.USED:
             raise RuntimeError(
-                "Can't run function `FlorisModel.get_farm_power` without "
-                "first running `FlorisModel.run`."
+                f"Can't run function `{self.__class__.__name__}.get_farm_power` without "
+                f"first running `{self.__class__.__name__}.run`."
             )
 
         if turbine_weights is None:
diff --git a/floris/par_floris_model.py b/floris/par_floris_model.py
new file mode 100644
index 000000000..9487c4e59
--- /dev/null
+++ b/floris/par_floris_model.py
@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import copy
+from pathlib import Path
+from time import perf_counter as timerpc
+
+import numpy as np
+
+from floris.core import State
+from floris.floris_model import FlorisModel
+
+
+class ParFlorisModel(FlorisModel):
+    """
+    This class mimics the FlorisModel, but enables parallelization of the main
+    computational effort.
+    """
+
+    def __init__(
+        self,
+        configuration: dict | str | Path | FlorisModel,
+        interface: str | None = "multiprocessing",
+        max_workers: int = -1,
+        n_wind_condition_splits: int = -1,
+        return_turbine_powers_only: bool = False,
+        print_timings: bool = False
+    ):
+        """
+        Initialize the ParFlorisModel object.
+
+        Args:
+            configuration: The Floris configuration dictionary or YAML file, or an instantiated
+                FlorisModel object. The configuration should have the following inputs specified.
+                - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details.
+                - **farm**: See `floris.simulation.farm.Farm` for more details.
+                - **turbine**: See `floris.simulation.turbine.Turbine` for more details.
+                - **wake**: See `floris.simulation.wake.WakeManager` for more details.
+                - **logging**: See `floris.simulation.core.Core` for more details.
+            interface: The parallelization interface to use. Options are "multiprocessing",
+               "pathos", and "concurrent", with possible future support for "mpi4py"
+            max_workers: The maximum number of workers to use. Defaults to -1, which then
+               takes the number of CPUs available.
+            n_wind_condition_splits: The number of wind conditions to split the simulation over.
+               Defaults to the same as max_workers.
+            return_turbine_powers_only: Whether to return only the turbine powers.
+            print_timings (bool): Print the computation time to the console. Defaults to False.
+        """
+        # Instantiate the underlying FlorisModel
+        if isinstance(configuration, FlorisModel):
+            configuration = configuration.core.as_dict()
+        super().__init__(configuration)
+
+        # Save parallelization parameters
+        if interface == "multiprocessing":
+            import multiprocessing as mp
+            self._PoolExecutor = mp.Pool
+            if max_workers == -1:
+                max_workers = mp.cpu_count()
+            # TODO: test spinning up the worker pool at this point
+        elif interface == "pathos":
+            import pathos
+            if max_workers == -1:
+                max_workers = pathos.helpers.cpu_count()
+            self.pathos_pool = pathos.pools.ProcessPool(nodes=max_workers)
+        elif interface == "concurrent":
+            from concurrent.futures import ProcessPoolExecutor
+            if max_workers == -1:
+                from multiprocessing import cpu_count
+                max_workers = cpu_count()
+            self._PoolExecutor = ProcessPoolExecutor
+        elif interface in ["mpi4py"]:
+            raise NotImplementedError(
+                f"Parallelization interface {interface} not yet supported."
+            )
+        elif interface is None:
+            self.logger.warning(
+                "No parallelization interface specified. Running in serial mode."
+            )
+            if return_turbine_powers_only:
+                self.logger.warn(
+                    "return_turbine_powers_only is not supported in serial mode."
+                )
+        else:
+            raise ValueError(
+                f"Invalid parallelization interface {interface}. "
+                "Options are 'multiprocessing', 'pathos', or 'concurrent'."
+            )
+
+        self._interface = interface
+        self.max_workers = max_workers
+        if n_wind_condition_splits == -1:
+            self.n_wind_condition_splits = max_workers
+        else:
+            self.n_wind_condition_splits = n_wind_condition_splits
+        self.return_turbine_powers_only = return_turbine_powers_only
+        self.print_timings = print_timings
+
+    def run(self) -> None:
+        """
+        Run the FLORIS model in parallel.
+        """
+
+        if self.return_turbine_powers_only:
+            # TODO: code here that does not return flow fields
+            # Somehow, overload methods on FlorisModel that need flow field
+            # data.
+
+            # This version will call super().get_turbine_powers() on each of
+            # the splits, and return them somehow.
+            self._stored_turbine_powers = None # Temporary
+        if self.interface is None:
+            t0 = timerpc()
+            super().run()
+            t1 = timerpc()
+        elif self.interface == "multiprocessing":
+            t0 = timerpc()
+            self.core.initialize_domain()
+            parallel_run_inputs = self._preprocessing()
+            t1 = timerpc()
+            if self.return_turbine_powers_only:
+                with self._PoolExecutor(self.max_workers) as p:
+                    self._turbine_powers_split = p.starmap(
+                        _parallel_run_powers_only,
+                        parallel_run_inputs
+                    )
+            else:
+                with self._PoolExecutor(self.max_workers) as p:
+                    self._fmodels_split = p.starmap(_parallel_run, parallel_run_inputs)
+            t2 = timerpc()
+            self._postprocessing()
+            self.core.farm.finalize(self.core.grid.unsorted_indices)
+            self.core.state = State.USED
+            t3 = timerpc()
+        elif self.interface == "pathos":
+            t0 = timerpc()
+            self.core.initialize_domain()
+            parallel_run_inputs = self._preprocessing()
+            t1 = timerpc()
+            if self.return_turbine_powers_only:
+                self._turbine_powers_split = self.pathos_pool.map(
+                    _parallel_run_powers_only_map,
+                    parallel_run_inputs
+                )
+            else:
+                self._fmodels_split = self.pathos_pool.map(
+                    _parallel_run_map,
+                    parallel_run_inputs
+                )
+            t2 = timerpc()
+            self._postprocessing()
+            self.core.farm.finalize(self.core.grid.unsorted_indices)
+            self.core.state = State.USED
+            t3 = timerpc()
+        elif self.interface == "concurrent":
+            t0 = timerpc()
+            self.core.initialize_domain()
+            parallel_run_inputs = self._preprocessing()
+            t1 = timerpc()
+            if self.return_turbine_powers_only:
+                with self._PoolExecutor(self.max_workers) as p:
+                    self._turbine_powers_split = p.map(
+                        _parallel_run_powers_only_map,
+                        parallel_run_inputs
+                    )
+                    self._turbine_powers_split = list(self._turbine_powers_split)
+            else:
+                with self._PoolExecutor(self.max_workers) as p:
+                    self._fmodels_split = p.map(
+                        _parallel_run_map,
+                        parallel_run_inputs
+                    )
+                    self._fmodels_split = list(self._fmodels_split)
+            t2 = timerpc()
+            self._postprocessing()
+            self.core.farm.finalize(self.core.grid.unsorted_indices)
+            self.core.state = State.USED
+            t3 = timerpc()
+        if self.print_timings:
+            print("===============================================================================")
+            if self.interface is None:
+                print(f"Total time spent for serial calculation (interface=None): {t1 - t0:.3f} s")
+            else:
+                print(
+                    "Total time spent for parallel calculation "
+                    f"({self.max_workers} workers): {t3-t0:.3f} s"
+                )
+                print(f"  Time spent in parallel preprocessing: {t1-t0:.3f} s")
+                print(f"  Time spent in parallel loop execution: {t2-t1:.3f} s.")
+                print(f"  Time spent in parallel postprocessing: {t3-t2:.3f} s")
+
+    def _preprocessing(self):
+        """
+        Prepare the input arguments for parallel execution.
+        """
+
+        # Split over the wind conditions
+        n_wind_condition_splits = self.n_wind_condition_splits
+        n_wind_condition_splits = np.min(
+            [n_wind_condition_splits, self.core.flow_field.n_findex]
+        )
+
+        # Prepare the input arguments for parallel execution
+        fmodel_dict = self.core.as_dict()
+        wind_condition_id_splits = np.array_split(
+            np.arange(self.core.flow_field.n_findex),
+            n_wind_condition_splits,
+        )
+        multiargs = []
+        for wc_id_split in wind_condition_id_splits:
+            # for ws_id_split in wind_speed_id_splits:
+            fmodel_dict_split = copy.deepcopy(fmodel_dict)
+            wind_directions = self.core.flow_field.wind_directions[wc_id_split]
+            wind_speeds = self.core.flow_field.wind_speeds[wc_id_split]
+            turbulence_intensities = self.core.flow_field.turbulence_intensities[wc_id_split]
+
+            # Extract and format all control setpoints as a dict that can be unpacked later
+            control_setpoints_subset = {
+                "yaw_angles": self.core.farm.yaw_angles[wc_id_split, :],
+                "power_setpoints": self.core.farm.power_setpoints[wc_id_split, :],
+                "awc_modes": self.core.farm.awc_modes[wc_id_split, :],
+                "awc_amplitudes": self.core.farm.awc_amplitudes[wc_id_split, :],
+                "awc_frequencies": self.core.farm.awc_frequencies[wc_id_split, :],
+            }
+            fmodel_dict_split["flow_field"]["wind_directions"] = wind_directions
+            fmodel_dict_split["flow_field"]["wind_speeds"] = wind_speeds
+            fmodel_dict_split["flow_field"]["turbulence_intensities"] = turbulence_intensities
+
+            # Prepare lightweight data to pass along
+            multiargs.append((fmodel_dict_split, control_setpoints_subset))
+
+        return multiargs
+
+    def _postprocessing(self):
+        # Append the remaining flow_fields
+        # Could consider adding a merge method to the FlowField class
+        # to make this easier
+
+        if self.return_turbine_powers_only:
+            self._stored_turbine_powers = np.vstack(self._turbine_powers_split)
+        else:
+            # Ensure fields to set have correct dimensions
+            self.core.flow_field.u = self._fmodels_split[0].core.flow_field.u
+            self.core.flow_field.v = self._fmodels_split[0].core.flow_field.v
+            self.core.flow_field.w = self._fmodels_split[0].core.flow_field.w
+            self.core.flow_field.turbulence_intensity_field = \
+                self._fmodels_split[0].core.flow_field.turbulence_intensity_field
+
+            for fm in self._fmodels_split[1:]:
+                self.core.flow_field.u = np.append(
+                    self.core.flow_field.u,
+                    fm.core.flow_field.u,
+                    axis=0
+                )
+                self.core.flow_field.v = np.append(
+                    self.core.flow_field.v,
+                    fm.core.flow_field.v,
+                    axis=0
+                )
+                self.core.flow_field.w = np.append(
+                    self.core.flow_field.w,
+                    fm.core.flow_field.w,
+                    axis=0
+                )
+                self.core.flow_field.turbulence_intensity_field = np.append(
+                    self.core.flow_field.turbulence_intensity_field,
+                    fm.core.flow_field.turbulence_intensity_field,
+                    axis=0
+                )
+
+    def _get_turbine_powers(self):
+        """
+        Calculates the power at each turbine in the wind farm.
+        This override will only be necessary if we want to be able to
+        use the return_turbine_powers_only option. Need to check if that
+        makes a significant speed difference.
+
+        Returns:
+            NDArrayFloat: Powers at each turbine.
+        """
+        if self.core.state is not State.USED:
+            self.logger.warning(
+                f"Please call `{self.__class__.__name__}.run` before computing"
+                " turbine powers. In future versions, an explicit run() call will"
+                "be required."
+            )
+            self.run()
+        if self.return_turbine_powers_only:
+            return self._stored_turbine_powers
+        else:
+            return super()._get_turbine_powers()
+
+    @property
+    def fmodel(self):
+        """
+        Raise deprecation warning.
+        """
+        self.logger.warning(
+            "ParFlorisModel no longer contains `fmodel` as an attribute "
+            "and now directly inherits from FlorisModel. Please use the "
+            "attributes and methods of FlorisModel directly."
+        )
+
+    @property
+    def interface(self):
+        """
+        The parallelization interface used.
+        """
+        return self._interface
+
+    @interface.setter
+    def interface(self, value):
+        """
+        Raise error regarding setting the interface.
+        """
+        raise AttributeError(
+            "The parallelization interface cannot be changed after instantiation."
+        )
+
+def _parallel_run(fmodel_dict, set_kwargs) -> FlorisModel:
+    """
+    Run the FLORIS model in parallel.
+
+    Args:
+        fmodel: The FLORIS model to run.
+        set_kwargs: Additional keyword arguments to pass to fmodel.set().
+    """
+    fmodel = FlorisModel(fmodel_dict)
+    fmodel.set(**set_kwargs)
+    fmodel.run()
+    return fmodel
+
+def _parallel_run_powers_only(fmodel_dict, set_kwargs) -> np.ndarray:
+    """
+    Run the FLORIS model in parallel, returning only the turbine powers.
+
+    Args:
+        fmodel: The FLORIS model to run.
+        set_kwargs: Additional keyword arguments to pass to fmodel.set().
+    """
+    fmodel = FlorisModel(fmodel_dict)
+    fmodel.set(**set_kwargs)
+    fmodel.run()
+    return fmodel.get_turbine_powers()
+
+def _parallel_run_map(x):
+    """
+    Wrapper for unpacking inputs to _parallel_run() for use with map().
+    """
+    return _parallel_run(*x)
+
+def _parallel_run_powers_only_map(x):
+    """
+    Wrapper for unpacking inputs to _parallel_run_powers_only() for use with map().
+    """
+    return _parallel_run_powers_only(*x)
diff --git a/floris/parallel_floris_model.py b/floris/parallel_floris_model.py
index 22d46ae36..9b0b0b355 100644
--- a/floris/parallel_floris_model.py
+++ b/floris/parallel_floris_model.py
@@ -70,9 +70,8 @@ def __init__(
         parallel computing to common FlorisModel properties.
 
         Args:
-        fmodel (FlorisModel or UncertainFlorisModel object): Interactive FLORIS object used to
-            perform the wake and turbine calculations. Can either be a regular FlorisModel
-            object or can be an UncertainFlorisModel object.
+        fmodel (FlorisModel object): Interactive FLORIS object used to
+            perform the wake and turbine calculations.
         max_workers (int): Number of parallel workers, typically equal to the number of cores
             you have on your system or HPC.
         n_wind_condition_splits (int): Number of sectors to split the wind findex array over.
@@ -89,6 +88,11 @@ def __init__(
         print_timings (bool): Print the computation time to the console. Defaults to False.
         """
 
+        self.logger.warning((
+            "ParallelFlorisModel is deprecated and will be removed in a future version. "
+            "Please switch to ParFlorisModel instead."
+        ))
+
         # Set defaults for backward compatibility
         if use_mpi4py is not None:
             warnings.warn(
@@ -112,11 +116,19 @@ def __init__(
             from concurrent.futures import ProcessPoolExecutor
             self._PoolExecutor = ProcessPoolExecutor
         else:
-            raise UserWarning(
+            raise ValueError(
                 f"Interface '{interface}' not recognized. "
                 "Please use 'concurrent', 'multiprocessing' or 'mpi4py'."
             )
 
+        # Raise error if uncertain model is passed in and refer to new parallel_floris_model_2
+        if isinstance(fmodel, UncertainFlorisModel):
+            raise ValueError(
+                "UncertainFlorisModel is not supported in this version of ParallelFlorisModel. "
+                "Please use the new version ParFlorisModel (par_floris_model) "
+                "for UncertainFlorisModel compatibility."
+            )
+
         # Initialize floris object and copy common properties
         if isinstance(fmodel, FlorisModel):
             self.fmodel = fmodel.copy()
diff --git a/floris/uncertain_floris_model.py b/floris/uncertain_floris_model.py
index 5927fe2c0..4d9d691f5 100644
--- a/floris/uncertain_floris_model.py
+++ b/floris/uncertain_floris_model.py
@@ -12,6 +12,7 @@
 from floris import FlorisModel
 from floris.core import State
 from floris.logging_manager import LoggingManager
+from floris.par_floris_model import ParFlorisModel
 from floris.type_dec import (
     floris_array_converter,
     NDArrayBool,
@@ -46,13 +47,10 @@ class UncertainFlorisModel(LoggingManager):
     conditions from within the expanded set of conditions are run.
 
     Args:
-        configuration (:py:obj:`dict`): The Floris configuration dictionary or YAML file.
-            The configuration should have the following inputs specified.
-                - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details.
-                - **farm**: See `floris.simulation.farm.Farm` for more details.
-                - **turbine**: See `floris.simulation.turbine.Turbine` for more details.
-                - **wake**: See `floris.simulation.wake.WakeManager` for more details.
-                - **logging**: See `floris.simulation.core.Core` for more details.
+        configuration (dict | str | Path | FlorisModel | ParFlorisModel):  The configuration
+            for the wind farm.  This can be a dictionary, a path to a yaml file, or a FlorisModel
+            or ParFlorisModel object.  If dict, str or Path, a new FlorisModel object is
+            created.  If a FlorisModel or ParFlorisModel object a copy of the object is made.
         wd_resolution (float, optional): The resolution of wind direction for generating
             gaussian blends, in degrees.  Defaults to 1.0.
         ws_resolution (float, optional): The resolution of wind speed, in m/s. Defaults to 1.0.
@@ -75,7 +73,7 @@ class UncertainFlorisModel(LoggingManager):
 
     def __init__(
         self,
-        configuration: dict | str | Path,
+        configuration: dict | str | Path | FlorisModel | ParFlorisModel,
         wd_resolution=1.0,  # Degree
         ws_resolution=1.0,  # m/s
         ti_resolution=0.01,
@@ -109,13 +107,18 @@ def __init__(
         self.weights = self._get_weights(self.wd_std, self.wd_sample_points)
 
         # Instantiate the un-expanded FlorisModel
-        self.fmodel_unexpanded = FlorisModel(configuration)
+        if isinstance(configuration, (FlorisModel, ParFlorisModel)):
+            self.fmodel_unexpanded = configuration.copy()
+        elif isinstance(configuration, (dict, str, Path)):
+            self.fmodel_unexpanded = FlorisModel(configuration)
+        else:
+            raise ValueError(
+                "configuration must be a FlorisModel, ParFlorisModel, dict, str, or Path"
+            )
 
         # Call set at this point with no arguments so ready to run
         self.set()
 
-        # Instantiate the expanded FlorisModel
-        # self.core_interface = FlorisModel(configuration)
 
     def set(
         self,
diff --git a/setup.py b/setup.py
index b3532ffd5..7e3a11be4 100644
--- a/setup.py
+++ b/setup.py
@@ -28,6 +28,7 @@
 
     # utilities
     "coloredlogs~=15.0",
+    "pathos~=0.3",
 ]
 
 # What packages are optional?


Test patch:
diff --git a/tests/par_floris_model_unit_test.py b/tests/par_floris_model_unit_test.py
new file mode 100644
index 000000000..9e56e4d8c
--- /dev/null
+++ b/tests/par_floris_model_unit_test.py
@@ -0,0 +1,288 @@
+
+import copy
+import logging
+
+import numpy as np
+import pytest
+
+from floris import (
+    FlorisModel,
+    TimeSeries,
+    WindRose,
+)
+from floris.par_floris_model import ParFlorisModel
+
+
+DEBUG = False
+VELOCITY_MODEL = "gauss"
+DEFLECTION_MODEL = "gauss"
+
+def test_None_interface(sample_inputs_fixture):
+    """
+    With interface=None, the ParFlorisModel should behave exactly like the FlorisModel.
+    (ParFlorisModel.run() simply calls the parent FlorisModel.run()).
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface=None,
+        n_wind_condition_splits=2 # Not used when interface=None
+    )
+
+    fmodel.run()
+    pfmodel.run()
+
+    f_turb_powers = fmodel.get_turbine_powers()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+def test_multiprocessing_interface(sample_inputs_fixture):
+    """
+    With interface="multiprocessing", the ParFlorisModel should return the same powers
+    as the FlorisModel.
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="multiprocessing",
+        n_wind_condition_splits=2
+    )
+
+    fmodel.run()
+    pfmodel.run()
+
+    f_turb_powers = fmodel.get_turbine_powers()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+def test_pathos_interface(sample_inputs_fixture):
+    """
+    With interface="pathos", the ParFlorisModel should return the same powers
+    as the FlorisModel.
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="pathos",
+        n_wind_condition_splits=2
+    )
+
+    fmodel.run()
+    pfmodel.run()
+
+    f_turb_powers = fmodel.get_turbine_powers()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+    # Run in powers_only mode
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="pathos",
+        n_wind_condition_splits=2,
+        return_turbine_powers_only=True
+    )
+
+    pfmodel.run()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+def test_concurrent_interface(sample_inputs_fixture):
+    """
+    With interface="concurrent", the ParFlorisModel should return the same powers
+    as the FlorisModel.
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="concurrent",
+        n_wind_condition_splits=2,
+    )
+
+    fmodel.run()
+    pfmodel.run()
+
+    f_turb_powers = fmodel.get_turbine_powers()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+    # Run in powers_only mode
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="concurrent",
+        n_wind_condition_splits=2,
+        return_turbine_powers_only=True
+    )
+
+    pfmodel.run()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+def test_return_turbine_powers_only(sample_inputs_fixture):
+    """
+    With return_turbine_powers_only=True, the ParFlorisModel should return only the
+    turbine powers, not the full results.
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="multiprocessing",
+        n_wind_condition_splits=2,
+        return_turbine_powers_only=True
+    )
+
+    fmodel.run()
+    pfmodel.run()
+
+    f_turb_powers = fmodel.get_turbine_powers()
+    pf_turb_powers = pfmodel.get_turbine_powers()
+
+    assert np.allclose(f_turb_powers, pf_turb_powers)
+
+def test_run_error(sample_inputs_fixture, caplog):
+    """
+    Check that an error is raised if an output is requested before calling run().
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    pfmodel = ParFlorisModel(
+        sample_inputs_fixture.core,
+        interface="multiprocessing",
+        n_wind_condition_splits=2
+    )
+
+    # In future versions, error will be raised
+    # with pytest.raises(RuntimeError):
+    #     pfmodel.get_turbine_powers()
+    # with pytest.raises(RuntimeError):
+    #     pfmodel.get_farm_AEP()
+
+    # For now, only a warning is raised for backwards compatibility
+    with caplog.at_level(logging.WARNING):
+        pfmodel.get_turbine_powers()
+    assert caplog.text != "" # Checking not empty
+    caplog.clear()
+
+def test_configuration_compatibility(sample_inputs_fixture, caplog):
+    """
+    Check that the ParFlorisModel is compatible with FlorisModel and
+    UncertainFlorisModel configurations.
+    """
+
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+
+    # Allowed to instantiate ParFlorisModel using fmodel
+    with caplog.at_level(logging.WARNING):
+        ParFlorisModel(fmodel)
+    assert caplog.text == "" # Checking empty
+    caplog.clear()
+
+    pfmodel = ParFlorisModel(sample_inputs_fixture.core)
+    with caplog.at_level(logging.WARNING):
+        pfmodel.fmodel
+    assert caplog.text != "" # Checking not empty
+    caplog.clear()
+
+    with pytest.raises(AttributeError):
+        pfmodel.fmodel.core
+
+def test_wind_data_objects(sample_inputs_fixture):
+    """
+    Check that the ParFlorisModel is compatible with WindData objects.
+    """
+
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(sample_inputs_fixture.core, max_workers=2)
+
+    # Create a wind rose and set onto both models
+    wind_speeds = np.array([8.0, 10.0, 12.0, 8.0, 10.0, 12.0])
+    wind_directions = np.array([270.0, 270.0, 270.0, 280.0, 280.0, 280.0])
+    wind_rose = WindRose(
+        wind_directions=np.unique(wind_directions),
+        wind_speeds=np.unique(wind_speeds),
+        ti_table=0.06
+    )
+    fmodel.set(wind_data=wind_rose)
+    pfmodel.set(wind_data=wind_rose)
+
+    # Run; get turbine powers; compare results
+    fmodel.run()
+    powers_fmodel_wr = fmodel.get_turbine_powers()
+    pfmodel.run()
+    powers_pfmodel_wr = pfmodel.get_turbine_powers()
+
+    assert powers_fmodel_wr.shape == powers_pfmodel_wr.shape
+    assert np.allclose(powers_fmodel_wr, powers_pfmodel_wr)
+
+    # Test a TimeSeries object
+    wind_speeds = np.array([8.0, 8.0, 9.0])
+    wind_directions = np.array([270.0, 270.0, 270.0])
+    values = np.array([30.0, 20.0, 10.0])
+    time_series = TimeSeries(
+        wind_directions=wind_directions,
+        wind_speeds=wind_speeds,
+        turbulence_intensities=0.06,
+        values=values,
+    )
+    fmodel.set(wind_data=time_series)
+    pfmodel.set(wind_data=time_series)
+
+    fmodel.run()
+    powers_fmodel_ts = fmodel.get_turbine_powers()
+    pfmodel.run()
+    powers_pfmodel_ts = pfmodel.get_turbine_powers()
+
+    assert powers_fmodel_ts.shape == powers_pfmodel_ts.shape
+    assert np.allclose(powers_fmodel_ts, powers_pfmodel_ts)
+
+def test_control_setpoints(sample_inputs_fixture):
+    """
+    Check that the ParFlorisModel is compatible with yaw angles.
+    """
+
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+    pfmodel = ParFlorisModel(sample_inputs_fixture.core, max_workers=2)
+
+    # Set yaw angles
+    yaw_angles = np.tile(np.array([[10.0, 20.0, 30.0]]), (fmodel.n_findex,1))
+    fmodel.set(yaw_angles=yaw_angles)
+    pfmodel.set(yaw_angles=yaw_angles)
+
+    # Run; get turbine powers; compare results
+    fmodel.run()
+    powers_fmodel = fmodel.get_turbine_powers()
+    pfmodel.run()
+    powers_pfmodel = pfmodel.get_turbine_powers()
+
+    assert powers_fmodel.shape == powers_pfmodel.shape
+    assert np.allclose(powers_fmodel, powers_pfmodel)
diff --git a/tests/parallel_floris_model_integration_test.py b/tests/parallel_floris_model_integration_test.py
index 710557734..21857b5b3 100644
--- a/tests/parallel_floris_model_integration_test.py
+++ b/tests/parallel_floris_model_integration_test.py
@@ -1,7 +1,9 @@
 
 import copy
+import logging
 
 import numpy as np
+import pytest
 
 from floris import (
     FlorisModel,
@@ -17,6 +19,26 @@
 VELOCITY_MODEL = "gauss"
 DEFLECTION_MODEL = "gauss"
 
+def test_raise_deprecation_warning(sample_inputs_fixture, caplog):
+    """
+    Test that a warning is raised when instantiating the ParallelFlorisModel.
+    """
+    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
+    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
+
+    fmodel = FlorisModel(sample_inputs_fixture.core)
+
+    caplog.clear()
+    with caplog.at_level(logging.WARNING):
+        ParallelFlorisModel(
+            fmodel=fmodel,
+            max_workers=2,
+            n_wind_condition_splits=2,
+            interface="concurrent",
+            print_timings=False,
+        )
+    assert caplog.text != "" # Checking not empty
+    caplog.clear()
 
 def test_parallel_turbine_powers(sample_inputs_fixture):
     """
@@ -76,96 +98,24 @@ def test_parallel_get_AEP(sample_inputs_fixture):
 
     assert np.allclose(parallel_farm_AEP, serial_farm_AEP)
 
-def test_parallel_uncertain_turbine_powers(sample_inputs_fixture):
-    """
-
-    """
-    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
-    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
-
-    ufmodel = UncertainFlorisModel(
-        sample_inputs_fixture.core,
-        wd_sample_points=[-3, 0, 3],
-        wd_std=3
-    )
-    pfmodel_input = copy.deepcopy(ufmodel)
-    ufmodel.run()
-
-    serial_turbine_powers = ufmodel.get_turbine_powers()
-
-    pfmodel = ParallelFlorisModel(
-        fmodel=pfmodel_input,
-        max_workers=2,
-        n_wind_condition_splits=2,
-        interface="multiprocessing",
-        print_timings=False,
-    )
-
-    parallel_turbine_powers = pfmodel.get_turbine_powers()
-
-    if DEBUG:
-        print(serial_turbine_powers)
-        print(parallel_turbine_powers)
-
-    assert_results_arrays(parallel_turbine_powers, serial_turbine_powers)
-
-def test_parallel_uncertain_get_AEP(sample_inputs_fixture):
-    """
-
-    """
-    sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
-    sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
-
-    freq=np.linspace(0, 1, 16)/8
-
-    ufmodel = UncertainFlorisModel(
-        sample_inputs_fixture.core,
-        wd_sample_points=[-3, 0, 3],
-        wd_std=3
-    )
-    pfmodel_input = copy.deepcopy(ufmodel)
-    ufmodel.run()
-    serial_farm_AEP = ufmodel.get_farm_AEP(freq=freq)
-
-    pfmodel = ParallelFlorisModel(
-        fmodel=pfmodel_input,
-        max_workers=2,
-        n_wind_condition_splits=2,
-        interface="multiprocessing",
-        print_timings=False,
-    )
-
-    parallel_farm_AEP = pfmodel.get_farm_AEP(freq=freq)
-
-    assert np.allclose(parallel_farm_AEP, serial_farm_AEP)
-
-
-def test_parallel_uncertain_get_AEP_no_wake(sample_inputs_fixture):
+def test_parallel_uncertain_error(sample_inputs_fixture):
     """
 
     """
     sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL
     sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL
 
-    freq=np.linspace(0, 1, 16)/8
-
     ufmodel = UncertainFlorisModel(
         sample_inputs_fixture.core,
         wd_sample_points=[-3, 0, 3],
         wd_std=3
     )
-    pfmodel_input = copy.deepcopy(ufmodel)
-    ufmodel.run_no_wake()
-    serial_farm_AEP = ufmodel.get_farm_AEP(freq=freq)
 
-    pfmodel = ParallelFlorisModel(
-        fmodel=pfmodel_input,
-        max_workers=2,
-        n_wind_condition_splits=2,
-        interface="multiprocessing",
-        print_timings=False,
-    )
-
-    parallel_farm_AEP = pfmodel.get_farm_AEP(freq=freq, no_wake=True)
-
-    assert np.allclose(parallel_farm_AEP, serial_farm_AEP)
+    with pytest.raises(ValueError):
+        ParallelFlorisModel(
+            fmodel=ufmodel,
+            max_workers=2,
+            n_wind_condition_splits=2,
+            interface="multiprocessing",
+            print_timings=False,
+        )
diff --git a/tests/uncertain_floris_model_integration_test.py b/tests/uncertain_floris_model_integration_test.py
index 9295965af..e8e95d513 100644
--- a/tests/uncertain_floris_model_integration_test.py
+++ b/tests/uncertain_floris_model_integration_test.py
@@ -4,7 +4,11 @@
 import pytest
 import yaml
 
-from floris import FlorisModel, TimeSeries
+from floris import (
+    FlorisModel,
+    ParFlorisModel,
+    TimeSeries,
+)
 from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT
 from floris.uncertain_floris_model import (
     ApproxFlorisModel,
@@ -452,3 +456,16 @@ def test_set_operation_model():
     ufmodel.set(layout_x=[0, 0], layout_y=[0, 1000])
     with pytest.raises(ValueError):
         ufmodel.set(layout_x=[0, 0, 0], layout_y=[0, 1000, 2000])
+
+def test_parallel_uncertain_model():
+
+    ufmodel = UncertainFlorisModel(FlorisModel(configuration=YAML_INPUT))
+    pufmodel = UncertainFlorisModel(ParFlorisModel(configuration=YAML_INPUT))
+
+    # Run the models and compare outputs
+    ufmodel.run()
+    pufmodel.run()
+    powers_unc = ufmodel.get_turbine_powers()
+    powers_punc = pufmodel.get_turbine_powers()
+
+    assert np.allclose(powers_unc, powers_punc)