diff --git a/README.md b/README.md index 013209c7f..aee0959d7 100644 --- a/README.md +++ b/README.md @@ -86,10 +86,10 @@ FLORIS is a Python package run on the command line typically by providing an input file with an initial configuration. It can be installed with ```pip install floris``` (see [installation](https://github.nrel.io/floris/installation)). The typical entry point is -[FlorisInterface](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface) +[FlorisModel](https://nrel.github.io/floris/_autosummary/floris.floris.FlorisModel.html#floris.FlorisModel) which accepts the path to the input file as an argument. From there, changes can be made to the initial configuration through the -[FlorisInterface.reinitialize](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.reinitialize) +[FlorisModel.reinitialize](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.reinitialize) routine, and the simulation is executed with [FlorisInterface.calculate_wake](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.calculate_wake). diff --git a/docs/examples.md b/docs/examples.md index 73fcbda00..74108924e 100644 --- a/docs/examples.md +++ b/docs/examples.md @@ -186,7 +186,7 @@ and thrust coefficients or as absolute values. ## Optimization These examples demonstrate use of the optimization routines -included in FLORIS through {py:mod}`floris.tools.optimization`. These +included in FLORIS through {py:mod}`floris.optimization`. These focus on yaw settings and wind farm layout, but the concepts are general and can be used for other optimizations. diff --git a/docs/floris_101.ipynb b/docs/floris_101.ipynb index 5b73de57f..06994803f 100644 --- a/docs/floris_101.ipynb +++ b/docs/floris_101.ipynb @@ -10,9 +10,13 @@ "\n", "FLORIS is a Python-based software library for calculating wind farm performance considering\n", "the effect of turbine-turbine interactions through their wakes.\n", - "There are two primary packages that make up the software:\n", - "- `floris.simulation`: simulation framework including wake model definitions\n", - "- `floris.tools`: utilities for pre and post processing as well as driving the simulation\n", + "There are two primary packages to understand when using FLORIS:\n", + "- `floris.core`: This package contains the core functionality for calculating the wind farm wake\n", + " and turbine-turbine interactions. This package is the computational engine of FLORIS.\n", + " All of the mathematical models and algorithms are implemented here.\n", + "- `floris`: This is the top-level package that provides most of the functionality that the\n", + " majority of users will need. The main entry point is `FlorisModel` which is a high-level\n", + " interface to the computational engine.\n", "\n", "\n", "\n", @@ -22,9 +26,9 @@ "2. Run the wind farm wake calculation\n", "3. Extract data and postprocess results\n", "\n", - "Generally, users will only interact with `floris.tools` and most often through\n", - "the `FlorisInterface` class. Additionally, `floris.tools` contains functionality\n", - "for comparing results, creating visualizations, and developing optimization cases. \n", + "Generally, users will only interact with `floris` and most often through the `FlorisModel` class.\n", + "Additionally, `floris` contains functionality for comparing results, creating visualizations,\n", + "and developing optimization cases. \n", "\n", "This notebook steps through the basic ideas and operations of FLORIS while showing\n", "realistic uses and expected behavior." @@ -35,9 +39,9 @@ "id": "699c51dd", "metadata": {}, "source": [ - "## Initialize FlorisInterface\n", + "## Initialize Floris\n", "\n", - "The `FlorisInterface` provides functionality to build a wind farm representation and drive\n", + "The `FlorisModel` class provides functionality to build a wind farm representation and drive\n", "the simulation. This object is created (instantiated) by passing the path to a FLORIS input\n", "file as the only argument. After this object is created, it can immediately be used to\n", "inspect the data." @@ -64,10 +68,10 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "from floris.tools import FlorisInterface\n", + "from floris import FlorisModel\n", "\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "x, y = fi.get_turbine_layout()\n", + "fmodel = FlorisModel(\"gch.yaml\")\n", + "x, y = fmodel.get_turbine_layout()\n", "\n", "print(\" x y\")\n", "for _x, _y in zip(x, y):\n", @@ -85,7 +89,7 @@ "However, it is often simplest to define a basic configuration in the input file as\n", "a starting point and then make modifications in the Python script. This allows for\n", "generating data algorithmically or loading data from a data file. Modifications to\n", - "the wind farm representation are handled through the `FlorisInterface.reinitialize()`\n", + "the wind farm representation are handled through the `FlorisModel.set()`\n", "function with keyword arguments. Another way to think of this function is that it\n", "changes the value of inputs specified in the input file.\n", "\n", @@ -114,9 +118,9 @@ "source": [ "x_2x2 = [0, 0, 800, 800]\n", "y_2x2 = [0, 400, 0, 400]\n", - "fi.reinitialize(layout_x=x_2x2, layout_y=y_2x2)\n", + "fmodel.set(layout_x=x_2x2, layout_y=y_2x2)\n", "\n", - "x, y = fi.get_turbine_layout()\n", + "x, y = fmodel.get_turbine_layout()\n", "\n", "print(\" x y\")\n", "for _x, _y in zip(x, y):\n", @@ -128,14 +132,13 @@ "id": "63f45e11", "metadata": {}, "source": [ - "Additionally, we can change the wind speeds and wind directions.\n", - "The set of wind conditions is given as arrays of wind speeds and\n", - "wind directions that combined describe the atmospheric conditions\n", - "to compute. This requires that the wind speed and wind direction\n", - "arrays be the same length.\n", + "Additionally, we can change the wind speeds, wind directions, and turbulence intensity.\n", + "The set of wind conditions is given as arrays of wind speeds, wind directions, and turbulence\n", + "intensity combinations that describe the atmospheric conditions to compute.\n", + "This requires that all arrays be the same length.\n", "\n", - "Notice that we can give `FlorisInterface.reinitialize()` multiple keyword arguments at once.\n", - "Note that there is no expected output from the `FlorisInterface.reinitialize()` function." + "Notice that we can give `FlorisModel.set()` multiple keyword arguments at once.\n", + "There is no expected output from the `FlorisModel.set()` function." ] }, { @@ -145,17 +148,19 @@ "metadata": {}, "outputs": [], "source": [ - "# One wind direction and one speed\n", - "# -> one atmospheric condition (270 degrees at 8 m/s)\n", - "fi.reinitialize(wind_directions=[270.0], wind_speeds=[8.0])\n", + "fmodel.set(wind_directions=[270.0], wind_speeds=[8.0], turbulence_intensities=[0.1])\n", "\n", - "# Two wind directions and one speed (repeated)\n", - "# -> two atmospheric conditions (270 degrees at 8 m/s and 280 degrees at 8 m/s)\n", - "fi.reinitialize(wind_directions=[270.0, 280.0], wind_speeds=[8.0, 8.0])\n", + "fmodel.set(\n", + " wind_directions=[270.0, 280.0],\n", + " wind_speeds=[8.0, 8.0],\n", + " turbulence_intensities=[0.1, 0.1],\n", + ")\n", "\n", - "# Two wind directions and two speeds combined\n", - "# -> four atmospheric conditions (270 degrees at 8 m/s and 9 m/s, 280 degrees at 8 m/s and 9 m/s)\n", - "fi.reinitialize(wind_directions=[270.0, 280.0, 270.0, 280.0], wind_speeds=[8.0, 8.0, 9.0, 9.0])" + "fmodel.set(\n", + " wind_directions=[270.0, 280.0, 270.0, 280.0],\n", + " wind_speeds=[8.0, 8.0, 9.0, 9.0],\n", + " turbulence_intensities=[0.1, 0.1, 0.1, 0.1],\n", + ")" ] }, { @@ -163,7 +168,7 @@ "id": "da4f3309", "metadata": {}, "source": [ - "`FlorisInterface.reinitialize()` creates all of the basic data structures required\n", + "`FlorisModel.set()` creates all of the basic data structures required\n", "for the simulation but it does not do any aerodynamic calculations. The low level\n", "data structures have a complex shape that enables faster computations. Specifically,\n", "most data is structured as a 4-dimensional Numpy array with the following dimensions:\n", @@ -210,28 +215,26 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"Dimensions of grid x-components\")\n", - "print(np.shape(fi.floris.grid.x_sorted))\n", + "print(np.shape(fmodel.core.grid.x_sorted))\n", "\n", "print()\n", "print(\"3rd turbine x-components for first wind condition (at findex=0)\")\n", - "print(fi.floris.grid.x_sorted[0, 2, :, :])\n", + "print(fmodel.core.grid.x_sorted[0, 2, :, :])\n", "\n", - "x = fi.floris.grid.x_sorted[0, :, :, :]\n", - "y = fi.floris.grid.y_sorted[0, :, :, :]\n", - "z = fi.floris.grid.z_sorted[0, :, :, :]\n", + "x = fmodel.core.grid.x_sorted[0, :, :, :]\n", + "y = fmodel.core.grid.y_sorted[0, :, :, :]\n", + "z = fmodel.core.grid.z_sorted[0, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -245,12 +248,12 @@ "id": "ebfdc746", "metadata": {}, "source": [ - "## Execute wake calculation\n", + "## Run the Floris wake calculation\n", "\n", "Running the wake calculation is a one-liner. This will calculate the velocities\n", "at each turbine given the wake of other turbines for every wind speed and wind\n", - "direction combination. Since we have not explicitly specified yaw control settings,\n", - "all turbines are aligned with the inflow." + "direction combination. Since we have not explicitly specified yaw control settings\n", + "when creating the `FlorisModel` settings, all turbines are aligned with the inflow." ] }, { @@ -260,7 +263,7 @@ "metadata": {}, "outputs": [], "source": [ - "fi.calculate_wake()" + "fmodel.run()" ] }, { @@ -270,10 +273,9 @@ "source": [ "## Get turbine power\n", "\n", - "At this point, the simulation has completed and we can use the `FlorisInterface` to\n", + "At this point, the simulation has completed and we can use `FlorisModel` to\n", "extract useful information such as the power produced at each turbine. Remember that\n", - "we have configured the simulation with two wind directions, two wind speeds, and four\n", - "turbines." + "we have configured the simulation with four wind conditions and four turbines." ] }, { @@ -291,32 +293,32 @@ "\n", "Turbine powers for 8 m/s\n", "Wind condition 0\n", - " Turbine 0 - 1,691.33 kW\n", - " Turbine 1 - 1,691.33 kW\n", - " Turbine 2 - 592.65 kW\n", - " Turbine 3 - 592.98 kW\n", + " Turbine 0 - 1,753.95 kW\n", + " Turbine 1 - 1,753.95 kW\n", + " Turbine 2 - 904.68 kW\n", + " Turbine 3 - 904.85 kW\n", "\n", "Wind condition 1\n", - " Turbine 0 - 1,691.33 kW\n", - " Turbine 1 - 1,691.33 kW\n", - " Turbine 2 - 1,631.07 kW\n", - " Turbine 3 - 1,629.76 kW\n", + " Turbine 0 - 1,753.95 kW\n", + " Turbine 1 - 1,753.95 kW\n", + " Turbine 2 - 1,644.86 kW\n", + " Turbine 3 - 1,643.39 kW\n", "\n", "Turbine powers for all turbines at all wind conditions\n", - "[[1691.32664838 1691.32664838 592.6531181 592.97842923]\n", - " [1691.32664838 1691.32664838 1631.06554071 1629.75543674]\n", - " [2407.84167188 2407.84167188 861.30649817 861.73255027]\n", - " [2407.84167188 2407.84167188 2321.40975418 2319.53218301]]\n" + "[[1753.95445918 1753.95445918 904.68478734 904.84672946]\n", + " [1753.95445918 1753.95445918 1644.85720431 1643.39012544]\n", + " [2496.42786184 2496.42786184 1276.4580679 1276.67310219]\n", + " [2496.42786184 2496.42786184 2354.40522998 2352.47398836]]\n" ] } ], "source": [ - "powers = fi.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", + "powers = fmodel.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", "\n", "print(\"Dimensions of `powers`\")\n", "print( np.shape(powers) )\n", "\n", - "N_TURBINES = fi.floris.farm.n_turbines\n", + "N_TURBINES = fmodel.core.farm.n_turbines\n", "\n", "print()\n", "print(\"Turbine powers for 8 m/s\")\n", @@ -337,23 +339,19 @@ "source": [ "## Applying yaw angles\n", "\n", - "Yaw angles are applied to turbines through the `FlorisInterface.calculate_wake` function.\n", + "Yaw angles are another configuration option through `FlorisModel.set`.\n", "In order to fit into the vectorized framework, the yaw settings must be represented as\n", "a `Numpy.array` with dimensions equal to:\n", "- 0: findex\n", "- 1: number of turbines\n", "\n", - "**Unlike the data configured in `FlorisInterface.reinitialize()`, yaw angles are not retained**\n", - "**in memory and must be provided each time `FlorisInterface.calculate_wake` is used.**\n", - "**If no yaw angles are given, all turbines will be aligned with the inflow.**\n", - "\n", "It is typically easiest to start with an array of 0's and modify individual\n", "turbine yaw settings, as shown below." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "be78e20d", "metadata": {}, "outputs": [ @@ -375,7 +373,7 @@ } ], "source": [ - "# Recall that the previous `fi.reinitialize()` command set up four atmospheric conditions\n", + "# Recall that the previous `fmodel.set()` command set up four atmospheric conditions\n", "# and there are 4 turbines in the farm. So, the yaw angles array must be 4x4.\n", "yaw_angles = np.zeros((4, 4))\n", "print(\"Yaw angle array initialized with 0's\")\n", @@ -385,7 +383,7 @@ "yaw_angles[:, 0] = 25\n", "print(yaw_angles)\n", "\n", - "fi.calculate_wake(yaw_angles=yaw_angles)" + "fmodel.set(yaw_angles=yaw_angles)" ] }, { @@ -408,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "205738aa", "metadata": {}, "outputs": [ @@ -417,16 +415,14 @@ "output_type": "stream", "text": [ "Power % difference with yaw\n", - " 270 degrees: 6.43%\n", - " 280 degrees: 0.05%\n" + " 270 degrees: 0.16%\n", + " 280 degrees: 0.17%\n" ] } ], "source": [ "# 1. Load an input file\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "\n", - "fi.floris.solver\n", + "fmodel = FlorisModel(\"gch.yaml\")\n", "\n", "# 2. Modify the inputs with a more complex wind turbine layout\n", "D = 126.0 # Design the layout based on turbine diameter\n", @@ -434,21 +430,23 @@ "y = [0, 3 * D, 0, 3 * D]\n", "wind_directions = [270.0, 280.0]\n", "wind_speeds = [8.0, 8.0]\n", + "turbulence_intensities = [0.1, 0.1]\n", "\n", "# Pass the new data to FlorisInterface\n", - "fi.reinitialize(\n", + "fmodel.set(\n", " layout_x=x,\n", " layout_y=y,\n", " wind_directions=wind_directions,\n", - " wind_speeds=wind_speeds\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\n", ")\n", "\n", "# 3. Calculate the velocities at each turbine for all atmospheric conditions\n", "# All turbines have 0 degrees yaw\n", - "fi.calculate_wake()\n", + "fmodel.run()\n", "\n", "# 4. Get the total farm power\n", - "turbine_powers = fi.get_turbine_powers() / 1000.0 # Given in W, so convert to kW\n", + "turbine_powers = fmodel.get_turbine_powers() / 1000.0 # Given in W, so convert to kW\n", "farm_power_baseline = np.sum(turbine_powers, 1) # Sum over the second dimension\n", "\n", "# 5. Develop the yaw control settings\n", @@ -457,12 +455,13 @@ "yaw_angles[0, 1] = 15 # At 270 degrees, yaw the second turbine 15 degrees\n", "yaw_angles[1, 0] = 10 # At 280 degrees, yaw the first turbine 10 degrees\n", "yaw_angles[1, 1] = 0 # At 280 degrees, yaw the second turbine 0 degrees\n", + "fmodel.set(yaw_angles=yaw_angles)\n", "\n", "# 6. Calculate the velocities at each turbine for all atmospheric conditions with the new yaw settings\n", - "fi.calculate_wake(yaw_angles=yaw_angles)\n", + "fmodel.run()\n", "\n", "# 7. Get the total farm power\n", - "turbine_powers = fi.get_turbine_powers() / 1000.0\n", + "turbine_powers = fmodel.get_turbine_powers() / 1000.0\n", "farm_power_yaw = np.sum(turbine_powers, 1)\n", "\n", "# 8. Compare farm power with and without wake steering\n", @@ -480,7 +479,7 @@ "## Visualization\n", "\n", "While comparing turbine and farm powers is meaningful, a picture is worth at least\n", - "1000 Watts, and the `FlorisInterface` provides powerful routines for visualization.\n", + "1000 Watts, and `FlorisModel` provides powerful routines for visualization.\n", "\n", "The visualization functions require that the user select a single atmospheric condition\n", "to plot. The internal data structures still have the same shape but the wind speed and\n", @@ -496,51 +495,75 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "8bb179ff", "metadata": {}, "outputs": [ + { + "ename": "ValueError", + "evalue": "turbulence_intensities must be length n_findex", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 12\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# ti = turbulence_intensities[0]\u001b[39;00m\n\u001b[1;32m 11\u001b[0m fmodel\u001b[38;5;241m.\u001b[39mreset_operation()\n\u001b[0;32m---> 12\u001b[0m horizontal_plane \u001b[38;5;241m=\u001b[39m \u001b[43mfmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcalculate_horizontal_plane\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwd\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mwd\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mws\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m90.0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 13\u001b[0m visualize_cut_plane(horizontal_plane, ax\u001b[38;5;241m=\u001b[39maxarr[\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m], title\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m270 - Aligned\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 14\u001b[0m plot_turbine_labels(fmodel, axarr[\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m], color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m\"\u001b[39m, backgroundcolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mk\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/Development/floris/floris/floris_model.py:543\u001b[0m, in \u001b[0;36mFlorisModel.calculate_horizontal_plane\u001b[0;34m(self, height, x_resolution, y_resolution, x_bounds, y_bounds, wd, ws, yaw_angles, power_setpoints, disable_turbines)\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[38;5;66;03m# Set the solver to a flow field planar grid\u001b[39;00m\n\u001b[1;32m 536\u001b[0m solver_settings \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 537\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtype\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mflow_field_planar_grid\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 538\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnormal_vector\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mz\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 541\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mflow_field_bounds\u001b[39m\u001b[38;5;124m\"\u001b[39m: [x_bounds, y_bounds],\n\u001b[1;32m 542\u001b[0m }\n\u001b[0;32m--> 543\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 544\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_directions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwd\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 545\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_speeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mws\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 546\u001b[0m \u001b[43m \u001b[49m\u001b[43msolver_settings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msolver_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 547\u001b[0m \u001b[43m \u001b[49m\u001b[43myaw_angles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43myaw_angles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 548\u001b[0m \u001b[43m \u001b[49m\u001b[43mpower_setpoints\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpower_setpoints\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 549\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisable_turbines\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisable_turbines\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 550\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 552\u001b[0m \u001b[38;5;66;03m# Calculate wake\u001b[39;00m\n\u001b[1;32m 553\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39msolve_for_viz()\n", + "File \u001b[0;32m~/Development/floris/floris/floris_model.py:170\u001b[0m, in \u001b[0;36mFlorisModel.set\u001b[0;34m(self, wind_speeds, wind_directions, wind_shear, wind_veer, reference_wind_height, turbulence_intensities, air_density, layout_x, layout_y, turbine_type, turbine_library_path, solver_settings, heterogenous_inflow_config, wind_data, yaw_angles, power_setpoints, disable_turbines)\u001b[0m\n\u001b[1;32m 168\u001b[0m _yaw_angles \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39myaw_angles\n\u001b[1;32m 169\u001b[0m _power_setpoints \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39mpower_setpoints\n\u001b[0;32m--> 170\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_reinitialize\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 171\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_speeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_speeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 172\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_directions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_directions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 173\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_shear\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_shear\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_veer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_veer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[43mreference_wind_height\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreference_wind_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbulence_intensities\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbulence_intensities\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 177\u001b[0m \u001b[43m \u001b[49m\u001b[43mair_density\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mair_density\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[43mlayout_x\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlayout_x\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[43mlayout_y\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlayout_y\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbine_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbine_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbine_library_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbine_library_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[43m \u001b[49m\u001b[43msolver_settings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msolver_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 183\u001b[0m \u001b[43m \u001b[49m\u001b[43mheterogenous_inflow_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheterogenous_inflow_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 184\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 185\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;66;03m# If the yaw angles or power setpoints are not the default, set them back to the\u001b[39;00m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;66;03m# previous setting\u001b[39;00m\n\u001b[1;32m 189\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (_yaw_angles \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m.\u001b[39mall():\n", + "File \u001b[0;32m~/Development/floris/floris/floris_model.py:319\u001b[0m, in \u001b[0;36mFlorisModel._reinitialize\u001b[0;34m(self, wind_speeds, wind_directions, wind_shear, wind_veer, reference_wind_height, turbulence_intensities, air_density, layout_x, layout_y, turbine_type, turbine_library_path, solver_settings, heterogenous_inflow_config, wind_data)\u001b[0m\n\u001b[1;32m 316\u001b[0m floris_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfarm\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m farm_dict\n\u001b[1;32m 318\u001b[0m \u001b[38;5;66;03m# Create a new instance of floris and attach to self\u001b[39;00m\n\u001b[0;32m--> 319\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore \u001b[38;5;241m=\u001b[39m \u001b[43mCore\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfloris_dict\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Development/floris/floris/type_dec.py:226\u001b[0m, in \u001b[0;36mFromDictMixin.from_dict\u001b[0;34m(cls, data)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m undefined:\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[1;32m 223\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe class definition for \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 224\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis missing the following inputs: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mundefined\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 225\u001b[0m )\n\u001b[0;32m--> 226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m:9\u001b[0m, in \u001b[0;36m__init__\u001b[0;34m(self, logging, solver, wake, farm, flow_field, name, description, floris_version)\u001b[0m\n\u001b[1;32m 7\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwake\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_wake(wake))\n\u001b[1;32m 8\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfarm\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_farm(farm))\n\u001b[0;32m----> 9\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mflow_field\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[43m__attr_converter_flow_field\u001b[49m\u001b[43m(\u001b[49m\u001b[43mflow_field\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 10\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_name(name))\n\u001b[1;32m 11\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdescription\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_description(description))\n", + "File \u001b[0;32m~/Development/floris/floris/type_dec.py:226\u001b[0m, in \u001b[0;36mFromDictMixin.from_dict\u001b[0;34m(cls, data)\u001b[0m\n\u001b[1;32m 221\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m undefined:\n\u001b[1;32m 222\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[1;32m 223\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe class definition for \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 224\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis missing the following inputs: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mundefined\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 225\u001b[0m )\n\u001b[0;32m--> 226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m:32\u001b[0m, in \u001b[0;36m__init__\u001b[0;34m(self, wind_speeds, wind_directions, wind_veer, wind_shear, air_density, turbulence_intensities, reference_wind_height, time_series, heterogenous_inflow_config, multidim_conditions)\u001b[0m\n\u001b[1;32m 30\u001b[0m __attr_validator_wind_speeds(\u001b[38;5;28mself\u001b[39m, __attr_wind_speeds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwind_speeds)\n\u001b[1;32m 31\u001b[0m __attr_validator_wind_directions(\u001b[38;5;28mself\u001b[39m, __attr_wind_directions, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mwind_directions)\n\u001b[0;32m---> 32\u001b[0m \u001b[43m__attr_validator_turbulence_intensities\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m__attr_turbulence_intensities\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mturbulence_intensities\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m __attr_validator_heterogenous_inflow_config(\u001b[38;5;28mself\u001b[39m, __attr_heterogenous_inflow_config, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mheterogenous_inflow_config)\n\u001b[1;32m 34\u001b[0m __attr_validator_het_map(\u001b[38;5;28mself\u001b[39m, __attr_het_map, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhet_map)\n", + "File \u001b[0;32m~/Development/floris/floris/core/flow_field.py:69\u001b[0m, in \u001b[0;36mFlowField.turbulence_intensities_validator\u001b[0;34m(self, instance, value)\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[38;5;66;03m# Check the turbulence intensity is length n_findex\u001b[39;00m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(value) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mn_findex:\n\u001b[0;32m---> 69\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mturbulence_intensities must be length n_findex\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: turbulence_intensities must be length n_findex" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "from floris.tools.visualization import visualize_cut_plane, add_turbine_id_labels\n", + "from floris.flow_visualization import visualize_cut_plane\n", + "from floris.layout_visualization import plot_turbine_labels\n", "\n", "fig, axarr = plt.subplots(2, 2, figsize=(15,8))\n", "\n", "# Plot the first wind condition\n", "wd = wind_directions[0]\n", "ws = wind_speeds[0]\n", + "# ti = turbulence_intensities[0]\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", + "fmodel.reset_operation()\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"270 - Aligned\")\n", - "add_turbine_id_labels(fi, axarr[0,0], color=\"w\", backgroundcolor=\"k\")\n", + "plot_turbine_labels(fmodel, axarr[0,0], color=\"w\", backgroundcolor=\"k\")\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wd], ws=[ws], yaw_angles=yaw_angles[0:1] , height=90.0)\n", + "fmodel.set(yaw_angles=yaw_angles[0:1])\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"270 - Yawed\")\n", - "add_turbine_id_labels(fi, axarr[0,1], color=\"w\", backgroundcolor=\"k\")\n", + "plot_turbine_labels(fmodel, axarr[0,1], color=\"w\", backgroundcolor=\"k\")\n", "\n", "# Plot the second wind condition\n", "wd = wind_directions[1]\n", "ws = wind_speeds[1]\n", + "# ti = turbulence_intensities[1]\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", + "fmodel.reset_operation()\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"280 - Aligned\")\n", - "add_turbine_id_labels(fi, axarr[1,0], color=\"w\", backgroundcolor=\"k\")\n", + "plot_turbine_labels(fmodel, axarr[1,0], color=\"w\", backgroundcolor=\"k\")\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wd], ws=[ws], yaw_angles=yaw_angles[1:2] , height=90.0)\n", + "fmodel.set(yaw_angles=yaw_angles[1:2])\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"280 - Yawed\")\n", - "add_turbine_id_labels(fi, axarr[1,1], color=\"w\", backgroundcolor=\"k\")\n", + "plot_turbine_labels(fmodel, axarr[1,1], color=\"w\", backgroundcolor=\"k\")\n", "\n", "plt.show()" ] @@ -558,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "3e517614", "metadata": {}, "outputs": [ @@ -588,12 +611,12 @@ } ], "source": [ - "from floris.tools.visualization import plot_rotor_values\n", + "from floris.flow_visualization import plot_rotor_values\n", "\n", - "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, findex=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig, _, _ , _ = plot_rotor_values(fmodel.core.flow_field.u, findex=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", "fig.suptitle(\"Wind direction 270\")\n", "\n", - "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, findex=1, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig, _, _ , _ = plot_rotor_values(fmodel.core.flow_field.u, findex=1, n_rows=1, n_cols=4, return_fig_objects=True)\n", "fig.suptitle(\"Wind direction 280\")\n", "\n", "plt.show()" @@ -626,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "774acfea", "metadata": {}, "outputs": [ @@ -653,9 +676,9 @@ ], "source": [ "# Get the grid points\n", - "xs = fi.floris.grid.x_sorted\n", - "ys = fi.floris.grid.y_sorted\n", - "zs = fi.floris.grid.z_sorted\n", + "xs = fmodel.core.grid.x_sorted\n", + "ys = fmodel.core.grid.y_sorted\n", + "zs = fmodel.core.grid.z_sorted\n", "\n", "# Consider the shape\n", "print(f\"shape of xs: {xs.shape}\")\n", @@ -699,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "ee1918d6", "metadata": {}, "outputs": [ @@ -749,16 +772,16 @@ "print(f\"Number of turbines = {len(x)}\")\n", "\n", "# Define several models\n", - "fi_jensen = FlorisInterface(\"jensen.yaml\")\n", - "fi_gch = FlorisInterface(\"gch.yaml\")\n", - "fi_cc = FlorisInterface(\"cc.yaml\")\n", + "fmodel_jensen = FlorisModel(\"jensen.yaml\")\n", + "fmodel_gch = FlorisModel(\"gch.yaml\")\n", + "fmodel_cc = FlorisModel(\"cc.yaml\")\n", "\n", "# Assign the layouts, wind speeds and directions\n", - "fi_jensen.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", - "fi_gch.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", - "fi_cc.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fmodel_jensen.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fmodel_gch.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fmodel_cc.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", "\n", - "def time_model_calculation(model_fi: FlorisInterface) -> Tuple[float, float]:\n", + "def time_model_calculation(model_fi: FlorisModel) -> Tuple[float, float]:\n", " \"\"\"\n", " This function performs the wake calculation for a given\n", " FlorisInterface object and computes the AEP while\n", @@ -779,9 +802,9 @@ " end = time.perf_counter()\n", " return aep, end - start\n", "\n", - "jensen_aep, jensen_compute_time = time_model_calculation(fi_jensen)\n", - "gch_aep, gch_compute_time = time_model_calculation(fi_gch)\n", - "cc_aep, cc_compute_time = time_model_calculation(fi_cc)\n", + "jensen_aep, jensen_compute_time = time_model_calculation(fmodel_jensen)\n", + "gch_aep, gch_compute_time = time_model_calculation(fmodel_gch)\n", + "cc_aep, cc_compute_time = time_model_calculation(fmodel_cc)\n", "\n", "print('Model AEP (GWh) Compute Time (s)')\n", "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"Jensen\", jensen_aep, jensen_compute_time))\n", @@ -808,7 +831,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "32a93c6d", "metadata": {}, "outputs": [], @@ -818,12 +841,12 @@ "y = np.zeros_like(x)\n", "wind_directions = np.arange(0.0, 360.0, 2.0)\n", "wind_speeds = 8.0 * np.ones_like(wind_directions)\n", - "fi_gch.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)" + "fmodel_gch.reinitialize(layout_x=x, layout_y=y, wind_directions=wind_directions, wind_speeds=wind_speeds)" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "7d773cdc", "metadata": {}, "outputs": [ @@ -843,11 +866,11 @@ } ], "source": [ - "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", + "from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", "\n", "# Define the SerialRefine optimization\n", "yaw_opt = YawOptimizationSR(\n", - " fi=fi_gch,\n", + " fi=fmodel_gch,\n", " minimum_yaw_angle=0.0, # Allowable yaw angles lower bound\n", " maximum_yaw_angle=25.0, # Allowable yaw angles upper bound\n", " Ny_passes=[5, 4],\n", @@ -925,7 +948,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.12.1" }, "vscode": { "interpreter": { diff --git a/docs/wake_models.ipynb b/docs/wake_models.ipynb index 5252f3f55..e1f37de4b 100644 --- a/docs/wake_models.ipynb +++ b/docs/wake_models.ipynb @@ -58,23 +58,25 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from floris.tools import FlorisInterface\n", - "import floris.tools.visualization as wakeviz\n", + "from floris import FlorisModel\n", + "import floris.flow_visualization as flowviz\n", + "import floris.layout_visualization as layoutviz\n", "\n", "NREL5MW_D = 126.0\n", "\n", "def model_plot(inputfile):\n", " fig, axes = plt.subplots(1, 1, figsize=(10, 10))\n", - " fi = FlorisInterface(inputfile)\n", - " fi.reinitialize(layout_x=np.array([0.0, 2*NREL5MW_D]), layout_y=np.array([0.0, 2*NREL5MW_D]))\n", " yaw_angles = np.zeros((1, 2))\n", " yaw_angles[:,0] = 20.0\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", - " height=90.0,\n", - " yaw_angles=yaw_angles\n", + " fmodel = FlorisModel(inputfile)\n", + " fmodel.set(\n", + " layout_x=np.array([0.0, 2*NREL5MW_D]),\n", + " layout_y=np.array([0.0, 2*NREL5MW_D]),\n", + " yaw_angles=yaw_angles,\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes, yaw_angles=yaw_angles)" + " horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0)\n", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes,yaw_angles=yaw_angles)" ] }, { @@ -99,14 +101,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -139,14 +139,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -175,14 +173,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -209,14 +205,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -286,43 +280,52 @@ " X1_BOUND = 1500\n", "\n", " # Set the combination method\n", - " fi = FlorisInterface(\"../examples/inputs/jensen.yaml\")\n", - " settings = fi.floris.as_dict()\n", + " fmodel = FlorisModel(\"../examples/inputs/jensen.yaml\")\n", + " settings = fmodel.core.as_dict()\n", " settings[\"wake\"][\"model_strings\"][\"combination_model\"] = method\n", - " fi = FlorisInterface(settings)\n", + " fmodel = FlorisModel(settings)\n", "\n", " # Plot two turbines individually\n", " fig, axes = plt.subplots(1, 2, figsize=(10, 10))\n", - " fi.reinitialize(layout_x=np.array([X_UPSTREAM]), layout_y=np.zeros(1))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_UPSTREAM]),\n", + " layout_y=np.zeros(1),\n", + " yaw_angles=np.array([[20.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " x_bounds=(X0_BOUND, X1_BOUND),\n", - " yaw_angles=np.array([[20.0]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[0])\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes[0])\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes[1])\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[0])\n", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes[0])\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[1])\n", "\n", - " fi.reinitialize(layout_x=np.array([X_DOWNSTREAM]), layout_y=np.zeros(1))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_DOWNSTREAM]),\n", + " layout_y=np.zeros(1),\n", + " yaw_angles=np.array([[0.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " x_bounds=(X0_BOUND, X1_BOUND),\n", - " yaw_angles=np.array([[0.0]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[1])\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes[0])\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes[1])\n", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes[1])\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[0])\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[1])\n", "\n", " # Plot the combination of turbines\n", " fig, axes = plt.subplots(1, 1, figsize=(10, 10))\n", - " fi.reinitialize(layout_x=np.array([X_UPSTREAM, X_DOWNSTREAM]), layout_y=np.zeros(2))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_UPSTREAM, X_DOWNSTREAM]),\n", + " layout_y=np.zeros(2),\n", + " yaw_angles=np.array([[20.0, 0.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " x_bounds=(X0_BOUND, X1_BOUND),\n", - " yaw_angles=np.array([[20.0, 0.0]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes)" + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes)" ] }, { @@ -345,26 +348,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAERCAYAAABFDFfwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDA0lEQVR4nO3deXxU9aH///eZNetM9g0SdkGWKgXBqLVSU7HFWqtXq9daXIrVC61U6la39vZa1Hrb2k1re6v+HldrtV+X1rVc3GsURVFAQBAEJCQBQjLZyDLz+f0RMpk5M5MEzM7r+XjEzJzzOZ/5nA9x5rznc87nWMYYIwAAAABAmGOwGwAAAAAAQw1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALBxDXYDBkIoFFJFRYXS09NlWdZgNwcAAADAIDHGqL6+XkVFRXI4Eo8bHRFBqaKiQsXFxYPdDAAAAABDxM6dOzV69OiE64+IoJSeni5JesAxTikWZxsCAAAAR6omE9LFoW3hjJDIERGUOk+3S7EcSrGcg9waAAAAAIOtp0tyGF4BAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYNOvQWn58uU67rjjlJ6erry8PJ111lnatGlTVJkDBw5o8eLFys7OVlpams455xxVVVVFldmxY4cWLFiglJQU5eXl6ZprrlF7e3t/Nh0AAADAEaxfg9Irr7yixYsX680339SKFSvU1tam0047TY2NjeEyP/jBD/SPf/xDjz32mF555RVVVFTo7LPPDq8PBoNasGCBWltb9cYbb+jBBx/UAw88oFtuuaU/mw4AAADgCGYZY8xAvdiePXuUl5enV155RSeffLLq6uqUm5urhx9+WP/2b/8mSdq4caOOPvpolZeX6/jjj9dzzz2nM844QxUVFcrPz5ck3Xvvvbruuuu0Z88eeTyeHl83EAjI7/frUecEpVjOft1HAAAAAENXkwnqvODHqqurk8/nS1huQK9RqqurkyRlZWVJklavXq22tjaVlZWFy0yZMkUlJSUqLy+XJJWXl2vGjBnhkCRJ8+fPVyAQ0Pr16+O+TktLiwKBQNQPAAAAAPTWgAWlUCikpUuX6sQTT9T06dMlSZWVlfJ4PMrIyIgqm5+fr8rKynCZyJDUub5zXTzLly+X3+8P/xQXF/fx3gAAAAAYyQYsKC1evFjr1q3TI4880u+vdcMNN6iuri78s3Pnzn5/TQAAAAAjh2sgXmTJkiV6+umn9eqrr2r06NHh5QUFBWptbVVtbW3UqFJVVZUKCgrCZVatWhVVX+eseJ1l7Lxer7xebx/vBQAAAIAjRb+OKBljtGTJEj3xxBN68cUXNW7cuKj1s2bNktvt1sqVK8PLNm3apB07dqi0tFSSVFpaqrVr16q6ujpcZsWKFfL5fJo6dWp/Nh8AAADAEapfR5QWL16shx9+WE899ZTS09PD1xT5/X4lJyfL7/frsssu09VXX62srCz5fD5973vfU2lpqY4//nhJ0mmnnaapU6fqoosu0p133qnKykrddNNNWrx4MaNGAAAAAPpFv04PbllW3OX333+/Lr74YkkdN5xdtmyZ/vKXv6ilpUXz58/X73//+6jT6rZv364rr7xSL7/8slJTU7Vw4ULdfvvtcrl6l/OYHhwAAACA1PvpwQf0PkqDhaAEAAAAQBqi91ECAAAAgOGAoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsOnXoPTqq6/qa1/7moqKimRZlp588smo9cYY3XLLLSosLFRycrLKysq0efPmqDI1NTW68MIL5fP5lJGRocsuu0wNDQ392WwAAAAAQ1zIWKo2haoyo7r9qTZFUT+1JqtX9bv6s/GNjY065phjdOmll+rss8+OWX/nnXfq17/+tR588EGNGzdON998s+bPn68PP/xQSUlJkqQLL7xQu3fv1ooVK9TW1qZLLrlEl19+uR5++OH+bDoAAACAPhAylhrkV1BOSZIl0235ntZ3alaqtptJyrD29lDSsj3rXQSyjDG9a8lnZFmWnnjiCZ111lmSOkaTioqKtGzZMv3whz+UJNXV1Sk/P18PPPCAzj//fG3YsEFTp07V22+/rdmzZ0uSnn/+eX31q1/Vp59+qqKiol69diAQkN/v16POCUqxnP2yfwAAAMBwdMAkK9TDiWa9CS/xylRplKrNKDnVLrfVKmOsOFtG19JbITmUbDVq0S/H9nobSQo0t2j0db9RXV2dfD5fwnL9OqLUnW3btqmyslJlZWXhZX6/X3PnzlV5ebnOP/98lZeXKyMjIxySJKmsrEwOh0NvvfWWvvGNb8Stu6WlRS0tLeHngUCg/3YEAAAAGADGSCHZv/Q//NGZoFzaqwLtMBPlVLD37ejhFSOF5NA3fjROE/N6GvU5XLn9VO8gBqXKykpJUn5+ftTy/Pz88LrKykrl5eVFrXe5XMrKygqXiWf58uX6yU9+0sctBgAAAAZWu3GpVlnaawpUobE6oOSo9ZFByJJRpg4tkKRaAZVYW/TNX87sk/bG118hqX8NWlDqTzfccIOuvvrq8PNAIKDi4uJBbBEAAABGqnbjUp2ytMcUqFKjFYo6xI4df4kON/HLdGpWmtrkksu0a97lY5ST2jWpmbGN3uyu9emkSZZSvW1RyxNdaONwGLmd6ZJGJXz9I9mgBaWCggJJUlVVlQoLC8PLq6qqdOyxx4bLVFdXR23X3t6umpqa8PbxeL1eeb3evm80AAAARoSgcWq/srXHFKlOmZK6P00tOpJ0lQvJoRrlq01uuUyb5i0qkdfVFlHSdu2P7SWMiQ08kUXTkw6o+JTJys1sldcTUnenmj33wB55XEF5XL0/jQ6JDVpQGjdunAoKCrRy5cpwMAoEAnrrrbd05ZVXSpJKS0tVW1ur1atXa9asWZKkF198UaFQSHPnzh2spgMAAGAABI0zPFLTqo4vwXueCiBkex4//NQoTw61q8H4NeNb05XkbpOMFRVaIreMHJWJLGNJGpVRq+J5k5Wb2SKPuz/mSTvQD3WiJ/0alBoaGrRly5bw823btmnNmjXKyspSSUmJli5dqv/6r//SpEmTwtODFxUVhWfGO/roo3X66adr0aJFuvfee9XW1qYlS5bo/PPP7/WMdwAAAOgfDSZdNcpT0DgTjopIicOK/fqaDh2/g3KpSqPUKq/qTaZmXDAldjTGVp99RrXuIkuhsZSR0qwUT5tOOi9DaSmfZRTGL8LMyNOvQemdd97RvHnzws87rxtauHChHnjgAV177bVqbGzU5ZdfrtraWp100kl6/vnnw/dQkqSHHnpIS5Ys0amnniqHw6FzzjlHv/71r/uz2QAAACNGjclVmzzdluntfWsitRmXtmuS9itXIdPz7Vd6M7m0nUNBzftOiYoy6nTs2clxtvmsOi/V4FQ1xBqw+ygNJu6jBAAAhqp241KDEt/Lxe5QQk2TSdVGzVST0tRikuKO4CQeCYp+ndhSRrP/fbwmF1SreN4U5Wa2RK+NuRYn8XU4MctsC11OI0f3t/mBOq5R+sLEj2Mmc0C0IX8fJQAAgOGizbjVLne3ZQ5nVMbIUoUp0SearP0mRw7b9TWdpeK/XuI6I0PQnH8foxmjdqvwi1OVGnF6WXdflceGnNgyDoeUmhyUNE5SS2yBOC0DhhOCEgAAGFG6m0UsUm+DTbvcWmNKVWVGqU7Zao84fPLqgNxWm3ofZuzlLBkjfXFhkcbn7tOYUycnbEeP1+PEaYLXE5IvtV3SREmtCesGEIugBAAAhr2QsVSjXH1qxusTc5SalB6x1ij+aWT2e9nYdaxvk1fNStGM0wt11LRC5WW2yu0J6UCLQ+kp7Zo2oT5huxJFschQ40trPxhm/JI4ZQoYKghKAABgQGw1U7TLjFHAZKhN0fc7jD/7WSd7yDEHf3etb5NH7XLLpTaN+doMZU8fLZcr2DHqEufamJhTy2zrIkdrPO6QJpU0yjljsvwZXdfK7NzuVNrOD1WUx2xnwEhEUAIAAJKkFuPVFjNNNcpVu3ErZL9RpiRFhZTYUZrYe9h0BJs2ubRbY1V82lFKLRgjf1q7vO5gzClyoe1bu17JRL5itFCc8ONyhpTqaVXx3ByNLitUxCS6fYRrbIAjCUEJAIBhJmQs1ZlMfWrG6YBSItYkPpDvDCydZRz2kGNJtSZDOzVRJV+eLLcVkuWIrc8Y23hPOMx0f02QW9IXZ+do2sSAnJ/LUHq6kRV3k9xu6wGAgUJQAgCgDxkjVZgSNcrXywkFpAQTJEeUMeHTzeqUpQqNVaUpVtA4NX5eca/b1WOYcQU17/hM5cwp1ujikFLTDm8EJfK0tsjHHaesFYmRGQDDAUEJAHDEaTFe7TfZCib4GEwcXuKLnNL5gJL1njlB+0yBapSndjkP1hlbn23OsjhL47eh+Lg8HV+arGO+XqCCwgQ3yuxheud4NTscktstfdabb0aOFMUfNQKAoY+ghD5jjFHLwY9et3Go1UqJWu9Wq1xW+2A0DcAIFvne45WlkJxqVlrUvWTsdprx+sDMVaUZrXplxFxXk0j8ABU9c5qRJaeCmvPtSfrinDzVuTPl9tjbHP076nHEBG2xc7VJCkn79khFE/Zp1Og2bsIJAP2EoIQ+02yk80JbJEnn6Q41W3lR34t6dEDF+ljjrE0qsD5VitU4OA0FMKK0yOjfgh3vPd/XEm3VbO2Puc7FRFyjI7XJreJZ2Tp+doqyP1egGitLltU521nEVhGBJt49aqLCzcHnDqeUWyhlZHU8zuqzPe2SlCKlphlCEgD0I4IS+kyT0sKPp59Zojmnjw4feEjS7r1erX99gp7/57FyWW1KVmdQ6pxBKd70r10XHRdop8Zam1Rg7VKy1dTfuwNgGHKc+mVNyJ+ivGNz5Us3UQEn/I5ipPT0kBrTcuTL7DjdLHMQ2wwAGJoISugzkRcJTyjN16gvT4xaP0rSsecWa+8ehxpWb1FNwN2xnVH4HhfR3+RaCh2ss7HJqT3rK/XWC6OVZJrk1QHFC1iObk+fMTFhrLO8QyE5raCyVK0J1gaCGDBMTczdq8Dn85Q+MUO+jO7L9rAaAHCEIyhhQLlcUkFhSDpj/CFtFwhYqnipWXnpJWpo8SgY6jrfpOvbYivujE5RMz11cw/DkCy9/8ImVZnRyrKq4xTuusQ60XUP0WU7QphLbcrXLmVYNXJan+0CaQAAgOGk/oBX1fVp2teQGj5+65zkJXw8ZX8uybJM/LJxlkVNIGNb1llPxMtIVm2v2k5QwrDg8xn5vj5WU74+ts/rNkZqarS0a5dDk0qztfGN/drb5owKXR3/03X+N3pb+4xOkc9DRtrx0sfyq1Y5qlS2qVKG9sZtR6LwlTiUxY6oWQrJZwWUqgAzTQEAcIQxIUtvfDxeXlfH5FnhsBFRJlEAiRc2ZMUPL53luwsvRpaq6tJlOYxy0hpV8IUp8rg6vkQ2JnpqHPsZRZHLTILlUWUS1Gdf31nGhALqDYISjniW1XFR9FGTg9Lk0Zr5b6PV0hL9P1SkmCl2I5/b1rW0WNrzrxRVvrtDu/Z/Tm+u2CVJ8qlWSerN6X3dp53YATKHjCwVabvyVKFsVR2spX/uWdJdvZaMUtTAKBoAAAPkpG8WqKU1YpYX2w2hE01W0/E79tgnJogcYnjJchiNKWySw5Erqfkw96rvBRoP9KocQQmwcXskt6evgoWROWGcMuaM02Qjfen6Y9X03scaU9SkicXRs/5FvkFF19BN7baVoZClVX/bqR37T9aqhz/p+pbos+yCor9Bim1dvNqNjCx51KrxZoPyrAr5tL/n1znEQHdo5bsvG/8eN4aROQD9qrXNUuXeJEmxpwp1fGMfZ1m43MHfMl2nLkXU0bVtN3VEvM9F/o49fSneSEScZRF197WWVoe2fpqqbbtS5HCYmPbG24+OdpqYdlmWidqPjgfG1jdxytr7Mt6yQ+zf8HKH0YTRjXK7Dv8YxJfaLqUe9uawISgB/Sy/IHqCicDOFjkcktNpL9kX4czouHOKNb3Fqa9cdEzX0kQhLN5LxpsCOcG1XwlbYaRgyNKqJ3erue0ovf7wNlvF3Y1ExVt26CEn3mv19rPbklGSmpSqek3Vu0q36nq5JQZbxykVUmMg4gAm3oFl5/IEZcIHVHHKDJXwvG+fQ5W7u745th9Ax+yX7WAx7n7b67ISHCRGbB9Z3hpifTQQ9u73aGdlctwD7/gH2BHvWZZUuTdJlXu9yvC1qaXFoUCjW9n+VsnqnJbedspQ5FT1puvdL/Jb/JiRgojRhHjr4o0sdPce31vxAoS9D+L9fxcvXEhS0wGnfGltmjy2QS1HTbe1uXN/7H1k37f4/aJ46yOXHawulKCv7GeXRP67xKsvXM50taN13cfKzWxRtr9NGBoISsAIk5wUUnJS726e2d8+/7UitbU7NPuM/JgPsUiJglynUOT6OHnLvr1Z/+7B5bZ64ga+rmWdr9NwwKOGVq9e/FOFqjRKPlMrhzpOIYy+Jiz25Md44k99n/h5vO3tZVxqk8dqOaR6DjWgHlrdh7pd96dtHkrdLaZdUsd9lHbsy1LDTofqd0qeJNsrdn7pbvtzsiLX2w/yOw/8bc+ljt8ut+RNUuLQFVmH/cDPkhxxwoZs9UTW0bmusV4Ktju0d68n+rrJg/+x70PXygQiy1jdle06uHU6peTkbuqUfX9MzEFx5L9HvKDX8Tz+AXVkmIvcha51Jqqv4wbByHXxDtS7a5uk+npLrc0urd6Q0REGDvZ95PWrHe9DHTc/juxW62A/h2QpLbld25OnqTHokPFJo2a1yu/vqzMbPpt49xZLdMB/8GGcclbUSvu0/VHLugk2hWlGHm/H45Q++nJxKPlkC6eqDzUEJQD9ZkzhIJ2PfNTEnsv0wBip9JxCVby0XhV1hTJxsmf428g45353PI8TzGJeJ/qb28SxwgrXd6DVJbcrpJMnfRzTlt7q6dviRPUdyrfMh3M6aXfbJaqnqbVVP/rZk5KktmPnqL7Fp0BLg3Z+sEGSNPm4KQfrPbhdSLaDsa5/g1Dnv7PpKNc5QtVZNvJgLthuKRiUxhzdHvfgLnyU3dM3yhE7lHB958hB1AGrM2J9x+8ZR6d37Ie62hn3prkm4kuLQygTuf8HGqWpkyWPJ6INcQ6qY/Yt4nmom7LGvl28g/Ue+i/e/kS9Rpw6p+bvVchYHf/+tgP3yJGFznXuo8eFR34i6wzFaVNsyDg4kpAWUm1btnzjpfadNUPqRsJ9M0I4tAIJ0FsEJQCIw7KkbH+bss86SjMGuzE2NXVurfnHTuX5Gga7KUNCY0tr+HFqmlGzR1r//galpHdMmLJz47v98rrBoEPZRZ8Pf8Mdqy8PDntXV8X+uj58zW5Yktvhl9MpOUfYkURAOf1Wd8QgVZQDkrIOPm7vt1cHcKiG0HcWAAAAADA0EJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG4ISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABshk1Q+t3vfqexY8cqKSlJc+fO1apVqwa7SQAAAABGqGERlP7617/q6quv1q233qp3331XxxxzjObPn6/q6urBbhoAAACAEWhYBKVf/OIXWrRokS655BJNnTpV9957r1JSUvTnP/95sJsGAAAAYAQa8kGptbVVq1evVllZWXiZw+FQWVmZysvLB7FlAAAAAEYq12A3oCd79+5VMBhUfn5+1PL8/Hxt3Lgx7jYtLS1qaWkJPw8EAv3aRgAAAAAjy5AfUTocy5cvl9/vD/8UFxcPdpMAAAAADCNDPijl5OTI6XSqqqoqanlVVZUKCgribnPDDTeorq4u/LNz586BaCoAAACAEWLIByWPx6NZs2Zp5cqV4WWhUEgrV65UaWlp3G28Xq98Pl/UDwAAAAD01pC/RkmSrr76ai1cuFCzZ8/WnDlz9Ktf/UqNjY265JJLBrtpAAAAAEagYRGUvvnNb2rPnj265ZZbVFlZqWOPPVbPP/98zAQPAAAAANAXhkVQkqQlS5ZoyZIlg90MAAAAAEeAIX+NEgAAAAAMNIISAAAAANgQlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsHENdgMwclgy4cdbdyar+PWNch1ztNLTTTdbAUDfaWuV9u+VUjOnKSnVyHS+/US+DRmFlztcUkq6UdW2NXK5gwPdXADAEEZQQp9JUUP48Qe/f03lVpE85mOden66jvpioVrGT5HUcYBiIg5aXC4pIyMkfwaBCsBns+25j1XfUit3u1NBSbKMLCk6KMmSJSkp36fU0T4F29Pky5mppJSOQka296mDv+3PQyFLDbWW9ldbUW2wLCnVZ+T29v3+AQAGDkEJfSbZkv7mnChJcpn/UaXGaL1m6dW/Fuu5v7ZI+uRgSSv826tmzT4zT9Pm5aj9+I5tje2bX0lKSw8pKWkAdgLAsJPicWv9T67X/oYUuV1vyrI632Oiv3zpHPU2slTblKIPd+drzbbR2lXrV3vQEfFVj7repiIfWp2JqSMMSZLHMmrc3BpRuGOFe2y6cmdmy1Xg1/bdATlsJ7qHQradMFG/ot8H7WUO/rYcktujcMADAPQtghL6jGVZSuo8pLCMCs0OpVoNChkrpqzDMmqQT1WmSBv+Pl2v/71eDrPlYD1S5yHN9NPyNX5OjiYUN8p7yqTwwQkAdLIsS8WZ7SrODBzSdseP364Dc97V9n0Z2lOf1lFXuM7osg5HdBhxKHE42bE/Q9u8s7T9nf1qbgkoGJIcjo6AY1my57e4wkUiyne1yZI/rU1p47Mlj0+NzXUd29hGzeJXmCCEHVzucBp5k2P3HwCORAQl9BunFVKm9sZ8XnfK1F4VW1t1jHlLe02+DlgpUet3aayKs0/Urvfatfa1VOX8fbU+96VMpc6cqNy8kJwRf72WxQc7gEOX5G7X5IK9mlywt8/qLKnbr/zqBk0rSFK7feRIkqz4MylZMrI6R62s6LfOju+PjIIhh2qaUvXJ3ixV/atKTWmjleRplwl/SWWrNFEoStB2h8MoaWKW3Hk+7WsMdIxWWfE3dPOeC2CEIyhh0LmtNhVan8Ys95v92vtIhbxKUZ5xaqcm6t1nRimorTrq1EK5nV0XXjsdIU06PluZs8eqaFRIKamcigJgcBT461Xgr+/X12hqdWv7vkytryhQY4u3K2DF0TVKZsK/YzNOx7qqQLpqqqdoV5VTklMHFD1RT2SlATXIXR+U5YitLathe1fNESNiaVNHqTktS5m5HacNAsBQRlDCkJVl7VGWtSf8/PMqV5NJVZUZpV0rxyp48M/XklGjkvXc82M0fn6NnKNLlOINyu3u+nBPSWrX0eMb5JpxlDKzTMz1AgAwnKR42nR0YbWOLqzu03o/qsrV+l21Km5IVXObW1L8oBQOWxsk6+BpifEGmKyI5e0hh7as26P0iYXan1+klFQjp/PgdWO2lzC267E6H8eeNhj9qk6nlO4zKiwMqsmf09PuAkC3CEoYVlKsRo2zPtI4fRSzbr2Zpep/bladSVe1PIo8R6RZqVohv46e36TcqQVKT22X29U1w5XUcd2Ux22Um9mq7JMmysOMVQCOMEfl79FR+Xt6LngYmlrdemXTRG2rrldg53bVB7u+sYo9ddrEv17MNnLmiDhd0RhLvsmj5A4Etal2nDKzasLLO353bRdKdEqi7VRJYzrKut1SgzdTWflSckr8bQGMPAQljBjTrNWaluCc+Rbj1RpTqsp/lmjnC+kKRlwhEDkT1jFnFWvPpDEqrP9Eyd7oT8xQSEryhORLa1fa8VO4JgoADkGKp02nT98QDi6Suj1lsGN97+tfs3OUNlXu16eb/QocqNG+RHWq4wuyzvf+7l6j47oxqS3kUHvQqdYpeUo5qlBp6UZeT8f2UZ8U9lGviJGxqMVGUkQ/5OYHVa1cpaT1alcBDBCCEo4IXqtFx+kVGTninB9iFJRLVWaUtj01RWvNBLWoYy5yS0ZGUkhOudWquefkK3N6iZJSXHK5uj5kc/OMsrJCnNIHAN3omHinf64hnTGqQpPyuk5F7CkAdce+bf0Br8o/Hqcdu+tUuXm3gib2y7bYOiLmfLeil9nnx1jb6lZySaGK8prUVjRWjY2W7Jd+xZutMCZ89VA+PZ1Tz4FDQVDCEcNhGUnBuOucalWxtU3F2qY241arus6767gGKl3VpkgfPT5V1f9vv0JaG14XkkMOE9Kcs7I1Y16uNGWSvN7oT6jOe6Y4HFJLrUejC5r7ZR8B4EjldBiletv6pe4kd7tOmvSx4k2D0amn8CXFD2/GSNWBdG2uztHGjfkKvFejN15uktM2JX3CV44XPDtHqywjYyy5HCGNnlMg/6zxGjWq63Owp/AVr0zs847XcjkNp6xjxCEoATZuq01uRX/YpqhRuValppg1arD8apc7vC5oHPrYmqZNT03Qmqd2qUWbYuq0ZHTsgnyNOS5fqcnOft8HAEDfykrtvy+4slKbNaWwWqdP36iaxlS1Bx29HnmLF74iQ1tb0KlP9mVp6wct2vZmtdY54s1Zf1A3Lxl1b6/OZcaSZRkVzCxSekpQk88cG9OenoNW4ueRj10ubgOCgUdQAg6B0wrJr/3RCy0pyRxQibVFbcYdd7sKjVWh/yRVvd+mXTUZ2pZVrzeTW8LrHQopN71RM88crdzM1v7cBQDAEOV2hpTv6/up5YuzanX8+E9UHUhTY6u349orWxnLEZuSYsrECW+bq3Ol1Hxtr0jWjj9UdbN14psdS5K2b+kqF1GHyxFU0XHFGlPYpNTjj+6mAqDvEZSAPuCzauVTbcJzI7ymRfV/qZRRsorUcfFvXXgSCYdqlKt3lKMX/7BdJ31nfNeGBz8tPK52+ZJbdMyZY5Wc1M23gQAAxOF2hjQqM9Dn9aZ5W1S9p065lkOhyIk6FGcEyJIcVvRnWLjMhNggFgw69en+DDWu36x/rUpW6qaK8Dr7BBnSwbkS40wtL8XOdJjsDWnC6EZp6hRlZIbkjv89J45w/RaUbrvtNj3zzDNas2aNPB6PamtrY8rs2LFDV155pV566SWlpaVp4cKFWr58uVyurma9/PLLuvrqq7V+/XoVFxfrpptu0sUXX9xfzQb6RaG1U4XWzoTrg8apWpOlCmuM1v5Px5S2nadOtChJbfKo1Xi1J5CqrLSm8HaWZVRw4mQV5LQqJSn+9VcAAPSX3PRG5aY39lv900bt1p76NO2sydCB2q6p662IqeG7lnXkpL/9tuHgmJmJKh/5vF0erVCyJn2lUZkpTcqfWRxeZ4wVO1GGiU594Xt9yZIlo8K8ZjmnTVZWVohrtUaQfgtKra2tOvfcc1VaWqr/+Z//iVkfDAa1YMECFRQU6I033tDu3bv17W9/W263Wz/72c8kSdu2bdOCBQt0xRVX6KGHHtLKlSv1ne98R4WFhZo/f35/NR0YcE4rqGxrj7IV//4l9cavahVqzf11OqCum3iE5FDTrxskI51wUbEm5u5V2uwZHR8HcU5xcDlCystulS+1nXO9AQBDntsZUlFGQEUZvRsNaw869KZVp2nWajnVnrBcq7zaZ/L06fPjtN4U6oP/t63beq2Y0NUlKKemfWO8gi/sV97nRik5KajU5PaOwGUf2Yq6yCt6XaDBo9pA7NBW54QZacntSvJyVslAsozp9ozRz+yBBx7Q0qVLY0aUnnvuOZ1xxhmqqKhQfn6+JOnee+/Vddddpz179sjj8ei6667TM888o3Xr1oW3O//881VbW6vnn3++120IBALy+/161DlBKRYX0mNkOWCStdfka5fGqlqjFFTX37jt+y+F5FTIOHTqJQUalVmropOjz/d2u0LK8rfKyf8mQ1pNnVtr/rFT8yZvHuymAMCQ0h506JfL6jTLek0uK3FQitRsUg5+CXl4h8RbzVR5dEA7zES1yKNWJUesTTB9fJzlloyS1WhbZylV9ZrznanKTG3WzLPGJLzWK96sjN0d5UeusywpNfnIOTMl0NikUWUXqK6uTj6fL2G5QbtGqby8XDNmzAiHJEmaP3++rrzySq1fv14zZ85UeXm5ysrKorabP3++li5d2m3dLS0tamnpulA+EOj7c3KBoSLJatZo6xON1icKGUuhqKAU+63XFk3T2w+M0YvKlPXL1VHrQ8ZSkg6o7LujNKlsrDLS43/IGCOlp7bL7erX71kAAOh3yVaTktXUc8EEJmqdmpWqXGt3H7aqw37lqsmkKtXborWfFmrtb7uZ8MmKDUbxJuDY8rcPwo+POneGCv0BWZJOOLdA/rToz/2EoSze1PImNqi5hvlxwqAFpcrKyqiQJCn8vLKystsygUBAzc3NSk5OVjzLly/XT37yk35oNTC0OSwjRzenGjgV1FFaqzGKPxLRanlVZUbr9fua9Mx9+2SZzpsjdk480fHsS5cVqCSzVlO/NjFqe7fLcEofAOCI4rf2x86I20cyzR7ttkr0yT3PyBtx8+JIvbmHV6TpETcdrvxblU66foLe3TFKT/65oeeNDzH35PnqVZJdq9FfOjrhl69D2SEFpeuvv1533HFHt2U2bNigKVOmfKZGfVY33HCDrr766vDzQCCg4uLibrYAjhwuq10uxX8zTFWDMq19mqL31WRS1WylRq03kj41E/TOn2u10mTKcdcHUes/f8EETczbq3GnTlJORuuw/yYJAIDB5LVaNLbzy81++CLSktGrd+xVyDgVksO2tucp4yPrsauXX9WSrEVztfb/q5XbGYxTa1eN8UakYibViJDqadXYnBrlnzxd2f6Wfrls4JCC0rJly3qccW78+PHdru9UUFCgVatWRS2rqqoKr+v83bkssozP50s4miRJXq9XXi9TjgCfRYrVqBTFzmSUY1Wrzbi1X9lqUXL4zTEkh/Y+skVrVaKWuxvkVoumfTP6GqjIN8HO0SlfUrN8yS068dxCpaUcOedHAwAw2Eqsjzse9EMIqzVZ2mEmassfX9YBJYdnCLTrbqKM7jQqXa8rXbrzdR1z4VTlpHZ8CRyvhpCJDoFJ7n29eo1DCkq5ubnKzc09lE0SKi0t1W233abq6mrl5eVJklasWCGfz6epU6eGyzz77LNR261YsUKlpaV90gYAh8dttSnPqoxZXqKtCpo3FbAytdcU6MCjGw6uif/GV69MVcqjeuNXXVOS3M5QuGSSq11jc/apaN40+dOYpQ8AgOEkw6pRhrWq54KHyRipQX7VWtna/fBufSS/pK6w1V3oSjIVCddF6rdrlHbs2KGamhrt2LFDwWBQa9askSRNnDhRaWlpOu200zR16lRddNFFuvPOO1VZWambbrpJixcvDo8GXXHFFfrtb3+ra6+9VpdeeqlefPFFPfroo3rmmWf6q9kAPiOnFVKm9inT6vnbms43uX3K0/b/rTr4bVOHZiVrhfI0fWuTfN4Dyk5rkMMy0bP6WB1D7ymeNk3/+qT+2SEAADDkWJaUrjqlq07F1tZD2rbJBKVenMTSb0Hplltu0YMPPhh+PnPmTEnSSy+9pFNOOUVOp1NPP/20rrzySpWWlio1NVULFy7Uf/7nf4a3GTdunJ555hn94Ac/0N13363Ro0frT3/6E/dQAkaI8JucVdd1DnaE7WaiKh/brh1Kl4k5d1pql1sLlhRpa126zEcd03ua9e92/I74IqnjNoOWHJaR02GUmdKkUV8+pl/2CQAAjAz9fh+loYD7KAEj03ozS/XGr33Kj3v/iOi7snf40qLRMsbSlNPGxJY+WDwns+OmvEMV91ECgPgO5z5KOPI0maDOC348dO+jBACf1dF6V8aKHWmK1TGn6k6N19o/VqhSxVrxp91R5y8H5VKSmlX23dGqcLdr0mkTYmtJ8LVSdkYr95QCAGCEISgBGLYcllGvTjI+aKw2a6y1WQdMcsw0qC1K0k4zQa//oVH1ypD1270Jauma5S9D+zT38ukq+cIEjcpvDpdI8gTlcROcAAAYzghKAI44SVZzzLIUNSrT2qc241aD/OEglWjWnBrlap/J12v3fazmP1TKUii8zqGgvnR5scbn7FP+KTOUmtQV5uLVxmgUAABDD0EJACK4rTZlKtFoUpcs7dE4bVJAmWq2UqLWBUyGXvtjq3adO0vmo6Ye68pOb9SEnL0qPGWasv2tcvTmbEIAANCvCEoAcJicVlCZ2qtM2/Iia4dyTaXq/vahjJFC6ppExj5CFZJDH6pIrytPM3fVyoQklzMUsb5jGgq3Myh/8gGle1s05Su9u7E3AAA4fAQlAOgH2Va1slXdq7udH6V12mKmqv6RD9VqvFFRypLUJrealaocVSnzwjNU8cheWUpWTWNyTF1eV7tSvW19th8AABypCEoAMARMtD7seJAgWO01edpvcrTlobdk5JBbrdqp5oObdEWrNnnkVovyrAqd/fNZkhLP1hc5pbrX1S6rF6EOAIAjBUEJAIaBHKtaOVa1JunDbssFjUMVGqudZoLu/mFtr+v/8rIpmla0W+6I0/4AADiSEZQAYARxWiEVa6tGaVvCMvbrpGqUp3/9okH/Z1LlODh7X+J5+CyF5NB/3JHFKX4AgBGNoAQAI1DHPaZ6J1sd11O1yqN2uSUlnhbdktH75nj94bo98saZZt0YhxxWUFf89yg5HEx7DgAYvghKAABJksdqlUetPZabrrfVKm/cdcZyaLOZrruv3qd0qy4qcBnbBVheNesr/3mcslKbCFUAgCGHoAQAOCSpVoNS1ZBw/XF6WQ3yq0lp3dbTrFQ9dPN2tcslv7VfX7hubsKJJyTJn3JAOWkNXEcFABgQBCUAQJ9yWEY+1cqn2p4LW1KTSdV+5eitO149uDA2LRk5VG/8alaqTlk6Vfm++uj1Jnq0yuUIKTutUUnu9sPcCwDAkY6gBAAYVClWo1LU2HNBS6o2hXrv7poE11B1LWuXR40mXR4d0DduOUrJ7u4nnvC625We1HKILQcAjGQEJQDAsJFn7VaedveqbLtc2qJpevw/t4Rn80s0SUWLvHKrTT6rRufdMT28vLtTASXJ4wpyKiAAjFAEJQDAiOSy2jVF7ye8iW+kkLFUqxxtNtP1u2u7RqwSBStJCsmhFKtBi34+Wh5XMG4ZY8SNfAFgmCIoAQCOeA7LKEt7NNd6qdfbNJlUbdXRPd7Y16GQ0q1anXbTsSryBxKGKgDA0EJQAgDgMKRYjZqud9Qmt0JyJBx9apdbAWXqiZ9+rHa55VXs/ac6RA89BeXUd24v5NopABgkBCUAAD4Dt9X9RBEetSpFjcpWlZqV2m3ZyLD1ofm8/nT9bqVa9TH3oIq3pUttuuyX43vbbABADwhKAAAMALfVJndvpkw/6Gi9pwNKltT9tVKWjEJyapuZrD/9YJvctpsGR27pkNGXfzyH+1EBQC8QlAAAGIJ8Vi/vRXVQmupUq2wF43y0dwatoJz6f7d+pGalKsVq0Ok/mh5TVoq9L5UkFfgDSvO2xikNACMTQQkAgBHgUO5HFTAZqlaRXvnZW90U6xqLajB+ea1mnfnjjmCV6FTANG8L11QBGDEISgAAHGEOdbSqUWnarRI9/uONkhLPuN5kUg/ej2q/vvbTY+WKOL3Pfk8qh2WUntTC9OkAhiyCEgAA6Faq1aCJ+rDHciFZCihTO8wk3X9TpZxqD6+zX2cVklOWjPxWjU6/daZy0xvi1hnvNMCO5V2P3c6QHI4e7g4MAIeIoAQAAPqEwzLKUI0yrMSn9HUyRmqUT/uVo4d+vOszvW62VaVLfznxM9UBAHYEJQAAMOAsS0pTQGkKaJS2ycgRsTb+6FC82f/qlK3NZrp+uXR/wmun7Ftd8OMSFWUEDrPlAI4UBCUAADCoHJaRFDysbTO1V5/X62qVN2GZyIC1S+P06I+D8lgdk050d48qYyw5rJAuvbNESe72hOUAjEwEJQAAMKy5rHa51LsgM958qHorQyE5I5bGjlRZMpIlfWQ+pz9ds0tJVlOv2xNZW4oadeEv40/DDmBoIygBAIAjhsMy8mt/r8tP0jq1KKlXZe2nBrYoSRVmjDbszo8p+86dL0mSZl87T76kA8pNb5DHdXijagD6B0EJAAAggUxr72Fv225ckiW9c+fOhGXevvNlNcivJpOmVKteX/jhbKUnHUhwlVbiWQA7jc6slTtiWnYAh4+gBAAA0A9cVrtK9HGvyrbKoz0qVPld5er+yqn4k1pIUq3J0pd/OFUFvq6JKrqryWmFlJPei5sUA0coghIAAMAg81itGqXtn6mO7ZqoV+5qlcOKfwqfPWA1mnRddltezAiU/ebAdp3hK8nVJq+b0wUxchGUAAAARoAx1haNsbb0qqwx0lrN0f03VkYFqESjVRFbHvyvQylWgxb9d3HimwLbnnNKIIYbghIAAMARxrKkz1mrDnv7WpOlTeYY/eLq3t+P6uwbx2pC7r7Dfk1goPVbUPrkk0/005/+VC+++KIqKytVVFSkb33rW7rxxhvl8XjC5T744AMtXrxYb7/9tnJzc/W9731P1157bVRdjz32mG6++WZ98sknmjRpku644w599atf7a+mAwAAoBsZVo1m6bUey3WOUO3UBD1+m+RWa4LrpmKXJVuN+vKPjlFuWoN8yS2ftcnAIeu3oLRx40aFQiH94Q9/0MSJE7Vu3TotWrRIjY2NuuuuuyRJgUBAp512msrKynTvvfdq7dq1uvTSS5WRkaHLL79ckvTGG2/oggsu0PLly3XGGWfo4Ycf1llnnaV3331X06dzXwIAAIDB4LJ6fxPeYvOxcqzdCU/tsy83stQon176WZvqTKYsSR4diLj+Kv7pfiHjlJTSi1MIgZ5ZxvR0yV7f+fnPf6577rlHW7dulSTdc889uvHGG1VZWRkeZbr++uv15JNPauPGjZKkb37zm2psbNTTTz8druf444/Xscceq3vvvbdXrxsIBOT3+/Woc4JSLGfPGwAAAGBICBlLAWWGbxLcUwhyql0+q3YAWobhqskEdV7wY9XV1cnn8yUs5xjANqmurk5ZWVnh5+Xl5Tr55JOjTsWbP3++Nm3apP3794fLlJWVRdUzf/58lZeXD0yjAQAAMGgcllGGVaMsa4+yrD3KtPZ2+0NIQl8ZsKC0ZcsW/eY3v9F3v/vd8LLKykrl50ffrbrzeWVlZbdlOtfH09LSokAgEPUDAAAAAL11yEHp+uuvl2VZ3f50njbXadeuXTr99NN17rnnatGiRX3W+ESWL18uv98f/ikuLu731wQAAAAwchzyZA7Lli3TxRdf3G2Z8ePHhx9XVFRo3rx5OuGEE3TfffdFlSsoKFBVVVXUss7nBQUF3ZbpXB/PDTfcoKuvvjr8PBAIEJYAAAAA9NohB6Xc3Fzl5ub2quyuXbs0b948zZo1S/fff78cjugBrNLSUt14441qa2uT2+2WJK1YsUKTJ09WZmZmuMzKlSu1dOnS8HYrVqxQaWlpwtf1er3yer2HuGcAAAAA0KHfrlHatWuXTjnlFJWUlOiuu+7Snj17VFlZGXVt0b//+7/L4/Hosssu0/r16/XXv/5Vd999d9Ro0FVXXaXnn39e//3f/62NGzfqxz/+sd555x0tWbKkv5oOAAAA4AjXb/dRWrFihbZs2aItW7Zo9OjRUes6ZyT3+/365z//qcWLF2vWrFnKycnRLbfcEr6HkiSdcMIJevjhh3XTTTfpRz/6kSZNmqQnn3ySeygBAAAA6DcDeh+lwcJ9lAAAAABIQ/Q+SgAAAAAwHBCUAAAAAMCGoAQAAAAANgQlAAAAALAhKAEAAACADUEJAAAAAGwISgAAAABgQ1ACAAAAABuCEgAAAADYEJQAAAAAwIagBAAAAAA2BCUAAAAAsCEoAQAAAIANQQkAAAAAbAhKAAAAAGBDUAIAAAAAG9dgN2AgGGMkSU0mNMgtAQAAADCYOjNBZ0ZI5IgISvv27ZMkXRzaNsgtAQAAADAU1NfXy+/3J1x/RASlrKwsSdKOHTu67Qx8doFAQMXFxdq5c6d8Pt9gN2dEo68HDn09cOjrgUV/Dxz6euDQ1wNnuPa1MUb19fUqKirqttwREZQcjo5Lsfx+/7D6RxzOfD4ffT1A6OuBQ18PHPp6YNHfA4e+Hjj09cAZjn3dm8ETJnMAAAAAABuCEgAAAADYHBFByev16tZbb5XX6x3spox49PXAoa8HDn09cOjrgUV/Dxz6euDQ1wNnpPe1ZXqaFw8AAAAAjjBHxIgSAAAAABwKghIAAAAA2BCUAAAAAMCGoAQAAAAANiMmKH3yySe67LLLNG7cOCUnJ2vChAm69dZb1draGlXugw8+0Be+8AUlJSWpuLhYd955Z0xdjz32mKZMmaKkpCTNmDFDzz777EDtxrD2u9/9TmPHjlVSUpLmzp2rVatWDXaThp3ly5fruOOOU3p6uvLy8nTWWWdp06ZNUWUOHDigxYsXKzs7W2lpaTrnnHNUVVUVVWbHjh1asGCBUlJSlJeXp2uuuUbt7e0DuSvDzu233y7LsrR06dLwMvq67+zatUvf+ta3lJ2dreTkZM2YMUPvvPNOeL0xRrfccosKCwuVnJyssrIybd68OaqOmpoaXXjhhfL5fMrIyNBll12mhoaGgd6VIS0YDOrmm2+O+iz86U9/qsh5m+jrw/fqq6/qa1/7moqKimRZlp588smo9X3Vt705VhnpuuvrtrY2XXfddZoxY4ZSU1NVVFSkb3/726qoqIiqg77unZ7+riNdccUVsixLv/rVr6KWj9i+NiPEc889Zy6++GLzwgsvmI8//tg89dRTJi8vzyxbtixcpq6uzuTn55sLL7zQrFu3zvzlL38xycnJ5g9/+EO4zL/+9S/jdDrNnXfeaT788ENz0003GbfbbdauXTsYuzVsPPLII8bj8Zg///nPZv369WbRokUmIyPDVFVVDXbThpX58+eb+++/36xbt86sWbPGfPWrXzUlJSWmoaEhXOaKK64wxcXFZuXKleadd94xxx9/vDnhhBPC69vb28306dNNWVmZee+998yzzz5rcnJyzA033DAYuzQsrFq1yowdO9Z87nOfM1dddVV4OX3dN2pqasyYMWPMxRdfbN566y2zdetW88ILL5gtW7aEy9x+++3G7/ebJ5980rz//vvmzDPPNOPGjTPNzc3hMqeffro55phjzJtvvmlee+01M3HiRHPBBRcMxi4NWbfddpvJzs42Tz/9tNm2bZt57LHHTFpamrn77rvDZejrw/fss8+aG2+80Tz++ONGknniiSei1vdF3/bmWOVI0F1f19bWmrKyMvPXv/7VbNy40ZSXl5s5c+aYWbNmRdVBX/dOT3/XnR5//HFzzDHHmKKiIvPLX/4yat1I7esRE5TiufPOO824cePCz3//+9+bzMxM09LSEl523XXXmcmTJ4efn3feeWbBggVR9cydO9d897vf7f8GD2Nz5swxixcvDj8PBoOmqKjILF++fBBbNfxVV1cbSeaVV14xxnR8OLjdbvPYY4+Fy2zYsMFIMuXl5caYjjc8h8NhKisrw2Xuuece4/P5ov720aG+vt5MmjTJrFixwnzxi18MByX6uu9cd9115qSTTkq4PhQKmYKCAvPzn/88vKy2ttZ4vV7zl7/8xRhjzIcffmgkmbfffjtc5rnnnjOWZZldu3b1X+OHmQULFphLL700atnZZ59tLrzwQmMMfd2X7AeUfdW3vTlWOdJ0d/DeadWqVUaS2b59uzGGvj5cifr6008/NaNGjTLr1q0zY8aMiQpKI7mvR8ypd/HU1dUpKysr/Ly8vFwnn3yyPB5PeNn8+fO1adMm7d+/P1ymrKwsqp758+ervLx8YBo9DLW2tmr16tVR/eZwOFRWVka/fUZ1dXWSFP47Xr16tdra2qL6esqUKSopKQn3dXl5uWbMmKH8/Pxwmfnz5ysQCGj9+vUD2PrhYfHixVqwYEHM//f0dd/5+9//rtmzZ+vcc89VXl6eZs6cqT/+8Y/h9du2bVNlZWVUX/v9fs2dOzeqrzMyMjR79uxwmbKyMjkcDr311lsDtzND3AknnKCVK1fqo48+kiS9//77ev311/WVr3xFEn3dn/qqb3tzrIJYdXV1sixLGRkZkujrvhQKhXTRRRfpmmuu0bRp02LWj+S+HrFBacuWLfrNb36j7373u+FllZWVUQc0ksLPKysruy3TuR6x9u7dq2AwSL/1sVAopKVLl+rEE0/U9OnTJXX8fXo8nvAHQafIvu7N3zk6PPLII3r33Xe1fPnymHX0dd/ZunWr7rnnHk2aNEkvvPCCrrzySn3/+9/Xgw8+KKmrr7p7D6msrFReXl7UepfLpaysLPo6wvXXX6/zzz9fU6ZMkdvt1syZM7V06VJdeOGFkujr/tRXfcv7yqE7cOCArrvuOl1wwQXy+XyS6Ou+dMcdd8jlcun73/9+3PUjua9dg92Anlx//fW64447ui2zYcMGTZkyJfx8165dOv3003Xuuedq0aJF/d1EoF8sXrxY69at0+uvvz7YTRmRdu7cqauuukorVqxQUlLSYDdnRAuFQpo9e7Z+9rOfSZJmzpypdevW6d5779XChQsHuXUjy6OPPqqHHnpIDz/8sKZNm6Y1a9Zo6dKlKioqoq8xIrW1tem8886TMUb33HPPYDdnxFm9erXuvvtuvfvuu7Isa7CbM+CG/IjSsmXLtGHDhm5/xo8fHy5fUVGhefPm6YQTTtB9990XVVdBQUHMjFWdzwsKCrot07kesXJycuR0Oum3PrRkyRI9/fTTeumllzR69Ojw8oKCArW2tqq2tjaqfGRf9+bvHB1v/tXV1fr85z8vl8sll8ulV155Rb/+9a/lcrmUn59PX/eRwsJCTZ06NWrZ0UcfrR07dkjq6qvu3kMKCgpUXV0dtb69vV01NTX0dYRrrrkmPKo0Y8YMXXTRRfrBD34QHjWlr/tPX/Ut7yu91xmStm/frhUrVoRHkyT6uq+89tprqq6uVklJSfizcvv27Vq2bJnGjh0raWT39ZAPSrm5uZoyZUq3P53nO+7atUunnHKKZs2apfvvv18OR/TulZaW6tVXX1VbW1t42YoVKzR58mRlZmaGy6xcuTJquxUrVqi0tLSf93T48ng8mjVrVlS/hUIhrVy5kn47RMYYLVmyRE888YRefPFFjRs3Lmr9rFmz5Ha7o/p606ZN2rFjR7ivS0tLtXbt2qg3rc4PEPvB6pHs1FNP1dq1a7VmzZrwz+zZs3XhhReGH9PXfePEE0+Mmeb+o48+0pgxYyRJ48aNU0FBQVRfBwIBvfXWW1F9XVtbq9WrV4fLvPjiiwqFQpo7d+4A7MXw0NTUFPPZ53Q6FQqFJNHX/amv+rY3xyroCkmbN2/W//3f/yk7OztqPX3dNy666CJ98MEHUZ+VRUVFuuaaa/TCCy9IGuF9PdizSfSVTz/91EycONGceuqp5tNPPzW7d+8O/3Sqra01+fn55qKLLjLr1q0zjzzyiElJSYmZHtzlcpm77rrLbNiwwdx6661MD94LjzzyiPF6veaBBx4wH374obn88stNRkZG1Gxg6NmVV15p/H6/efnll6P+hpuamsJlrrjiClNSUmJefPFF884775jS0lJTWloaXt85ZfVpp51m1qxZY55//nmTm5vLlNW9EDnrnTH0dV9ZtWqVcblc5rbbbjObN282Dz30kElJSTH/+7//Gy5z++23m4yMDPPUU0+ZDz74wHz961+PO63yzJkzzVtvvWVef/11M2nSJKastlm4cKEZNWpUeHrwxx9/3OTk5Jhrr702XIa+Pnz19fXmvffeM++9956RZH7xi1+Y9957LzzTWl/0bW+OVY4E3fV1a2urOfPMM83o0aPNmjVroj4vI2dVo697p6e/azv7rHfGjNy+HjFB6f777zeS4v5Eev/9981JJ51kvF6vGTVqlLn99ttj6nr00UfNUUcdZTwej5k2bZp55plnBmo3hrXf/OY3pqSkxHg8HjNnzhzz5ptvDnaThp1Ef8P3339/uExzc7P5j//4D5OZmWlSUlLMN77xjagvBIwx5pNPPjFf+cpXTHJyssnJyTHLli0zbW1tA7w3w489KNHXfecf//iHmT59uvF6vWbKlCnmvvvui1ofCoXMzTffbPLz843X6zWnnnqq2bRpU1SZffv2mQsuuMCkpaUZn89nLrnkElNfXz+QuzHkBQIBc9VVV5mSkhKTlJRkxo8fb2688caog0f6+vC99NJLcd+jFy5caIzpu77tzbHKSNddX2/bti3h5+VLL70UroO+7p2e/q7t4gWlkdrXljERt+sGAAAAAAz9a5QAAAAAYKARlAAAAADAhqAEAAAAADYEJQAAAACwISgBAAAAgA1BCQAAAABsCEoAAAAAYENQAgAAAAAbghIAAAAA2BCUAAAAAMCGoAQAAAAANgQlAAAAALD5/wEpWqt8k2mnzgAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -390,26 +389,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAADECAYAAABOQy+KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAApXUlEQVR4nO3deXAc533m8e+v58DgPgiQBMGbBMXLkkhRp6VIlmRLVhTLSeVwTtvxliobu5LsJpvYcVV2U7XZctZbTpzE5azKR+zYjux1fMi2YtmSfMiWREnWQZ2USPG2eIMAiXumf/vH9AAzmBkAJMDB9XyqQPa8/XajpzGYedDv0ebuiIiIiMjFF8z0AYiIiIgsFApeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIfGZPoDJaLSYLyYx04chIiIiMqE9DJ5097ZS6+ZE8FpMgr+Pr5rpwxARERGZ0J3pVw+UW6emRhEREZEKUfASERERqRAFLxEREZEKUfASERERqRAFLxEREZEKUfASERERqRAFLxEREZEKUfASERERqRAFLxEREZEKUfASERERqRAFLxEREZEKUfASERERqZApBy8zW2FmPzCzl8zsRTP746i8xcy+b2avRf83R+VmZv9gZnvMbJeZbZ/qMYiIiIjMBdNxxSsN/Km7bwauAd5vZpuBDwIPuXsn8FD0GODtQGf0dTfwyWk4BhEREZFZb8rBy93fcPeno+WzwMtAB3AX8Lmo2ueAd0bLdwGf96zHgSYza5/qcYiIiIjMdtPax8vMVgPbgJ3AEnd/I1p1FFgSLXcAh/I2OxyVjd3X3Wb2lJk91U1mOg9TREREZEZMW/Ayszrg34E/cfee/HXu7oCfz/7c/R533+HuOxqJTddhioiIiMyYaQleZpYgG7q+6O5fi4qP5ZoQo/+PR+VHgBV5my+PykRERETmtekY1WjAp4GX3f1jeavuA94dLb8b+GZe+e9FoxuvAbrzmiRFRERE5q34NOzjzcDvAs+b2bNR2V8CHwG+YmbvAw4Avx6tux+4A9gD9AHvnYZjEBEREZn1phy83P0ngJVZfUuJ+g68f6rfV0RERGSu0cz1IiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIQpeIiIiIhWi4CUiIiJSIfHp2ImZfQa4Ezju7lujshbgy8BqYD/w6+7eZWYGfBy4A+gD3uPuT0/HcYiIiIhcDMd9GWe8hTSJgnLDS9R+tex+piV4Af8C/BPw+byyDwIPuftHzOyD0eO/AN4OdEZfVwOfjP4XERERmXbucNYbOexrOM6ySW1jeEGoOkMrjZcuJWZpEpYp/70weOYrZddPS/By9x+b2eoxxXcBN0XLnwN+SDZ43QV83t0deNzMmsys3d3fmI5jERERkdkj7VOLGsdZxn6/hJO+mOExV5uCklebig2TZIgUqy+Ls+3KaszGVPDih05hpbrkEJcsPU77DRtJxMf/vv/z+vLrpuuKVylL8sLUUWBJtNwBHMqrdzgqKwheZnY3cDdA20U9TBERERlPxmP0UXfe23X5Il7zrRxlBRkCxuadnOLy0WATEmPtZQHXbmtgZUsXqcRwVKNwK/ei/DQiGQtZdeMKGmrT5/0cRtUCzZT/LpNTkUTj7m5m53Wk7n4PcA9Ap6Wm9ixFREQWuGFPcMKXMkTVpLfJRZsemtgfdnKM5QySIsEQ1dZfULf0B7XRzAnu/rOAVTesJhYU1/KxV5uKrj5ljyIwp7Wpqvhq1aRNJXRNn4sZvI7lmhDNrB04HpUfAVbk1VselYmIiEged9jnl9DlrWQKPrInfz3CMXpo4Tgd9HgjTZ310ZqJE4zh0ZWkgJaqM/zWDRnW39DG0VMprrv0VNljzpdM5Bq8Bid9zPPZxQxe9wHvBj4S/f/NvPIPmNm9ZDvVd6t/l4iIzEcZj3HSF/NquJUTUafu0bjjBctjGSFOQDeLqN3QRmAhVbGh8SOXW9GeAeKW4dJNjWy6rpn1t68oteWEV55SKccMhoeh+kf7J+znJKVN13QS/0a2I32rmR0G/jvZwPUVM3sfcAD49aj6/WSnkthDdjqJ907HMYiIiOSEbkXD/s/X676Rl30bp30xYZlpLwunEigOIoOkGKaKzk2DbN9eRYCPhqIxfZIKlqMHYWi01vfR8TtXsXRphvj0DImbjp3IBZquUY2/WWbVLSXqOvD+6fi+IiIyf4VudHsL6TEfVaXnTSr0Bit5MbyCN1jBIKmy2xsQJ02c4eLvT0DnpkHu+o31dCzuH9kuF5zyrwi5W8k8U51KU3/leurqphp2yk9fIHOLhguKiMi0SXucw76Gc17HeH2IjLDsOifgdd/IHrZyjgaCMXVL79XJTz5OwIo1w/zS1YO0veMK4lGzWBgWbjIwaAwPGxs3DhXtMRaDRYtCYrGyhzpJusIkoxS8RERkhDt0h8284pfRRVupGgWPxl59GqKK0ywhsXYZJwebiJeZaNJLbJu/15bUGd7zu+0MbttBqnoSI98KcxcWQGMTxCb4lIv1QfLUMdrbywdBkemk4CUiMk9kPMbhcBXP+rUcYU3emmwiKWxiKx16umnhDG0EDLP68oaRZrUwNBbV9lFTFc2hVGbOJAMWB86S+nNsefc6kquWFKwfG5iKyqLliQKTyFyll7aIyDQaDJPlO2KPM3o/7XH2hJt5khuj0JRfebyrTKPLw1QxTJKOjgHedNMSzCD04l0UtLaNudDT0jRM7bWbOYuRzJvu6cxJuGSVs2Ryd1sp68LnYBKZHxS8RETIduQ+Fi4r6oidM96tSTIe40W28wxv5lR0k47coP5RRvEgf8jFoABIMMjmKxP88i+v5Gx8UfaqUi4Y+dheTLnjHl2uTkG62qhvnlrAGQSSF765iIxDwWsOGPIkf5cZYIgkt3PNSHmMYdbYazQFp/VXpEgZH0v3c5Ymbhq5dWyOj0ShV7mM3VzKIDVkg1C5ObhH/y3cE7QsCrnm5irOrOqkKpW3h/wmuRLdiMIMDEXzSrYth3gCMm1QP+UO3SIyGyl4zQG9NPAqfaSr4jzQ8IfEguy799ljg6Q9QVPmFOt5nmTRcOjCv4+NXBOFExBSbz1stqdpC45V6qmIVNxuYKAKBmr+gP50FVg4phHPaGqOseOOFZzJnCBZFeatK6hYsn9STlWNczoAeIP+4pkJyjMYxli2bClLS89rKSLziILXHBEQ0lif4cY/u4y6FVEjRghNcefcIy/wzM7F9GN5sxYXyo9gYTpgMJ1gsKuLp39+Pamwj+zHT/YDJ/9DaWwH3ARDLLIT7LAfsSw4hMhcUFNjvPk3lvJaT5q+rlcK1jlGeijOmUyK+mbNlSQiF5eC1xxjBkGu324AZzG44U1cfsPk9+EO57qhI32CA4+3kAkLm05yjweHAjat7RnZJswEHDxWw75HD/AvB7YTDzMl59OxEk01YwOc4VTRz2aeZkvwMxrszOSfwAQMp8p0TzApFgROECv+s2R23DpXRBYCBa8FyAzqm6CHNprvLDVPT1Zw1lm3vbCs06Hr3esJThwnk9dfJdcE4x7N4BwJw1zZmJ07HHriJC8+1Mqj+99G6U7H+crPsWPkN6NmLeYIW+wplts+4mM+VouH0U/P5Ib5+w3IUG89JOx82pxERGS+U/CS82IGLW1A2+Ip7yu1uo322zdlr6blj9wqNc9P3vLq2qMFAa/wth2wf1+cn3+3mqd2d/LTQ6eIFdxqIxfv8me4Hm927bGPJw5pRoZWjrLGdtPMybLbFQ+ImMy+Jx8Sp6NuQEit9dBqxye9LxERKU/BS2ZMS2v26/wtHXftysXQuvVGru45RkdHmubmcEyYK3PDkcnMjD3Bdum0MfDsHu7/xzPsO3cH+/Lu7ZYfbtxtvLupjB6p5afKcrXKrMhLdrnvbThLa06O9x1HlgbDBIE7/S8eZAmHx6ldPuCNd1uYkmF0kmUw5tyMs/8Mj07mVIuIVISCl8w71TXZr5g7iQQkiyYkupj3TXMab1zLe29cW1g6iRB3IXUmX5aNHocfPsAN24rrlzKcNg796DV+3ARnhzaUqJGLXaVjTbnIld8UXbSuzFQNY39koZeeoLSU+CtPYkCyygn6dc88EZlZCl4iFTC2WbHy8675eX/fRNxZe8t61t5ykQ6pQr7xvhRnhuo41N9EPHFipg9HRBa4yf/ZKCIiIiJTouAlIiIiUiEKXiIiIiIVouAlIiIiUiEKXiIiIiIVouAlIiIiUiEKXiIiIiIVouAlIiIiUiEKXiIiIiIVouAlIiIiUiEzFrzM7HYz221me8zsgzN1HCIiIiKVMiPBy8xiwCeAtwObgd80s80zcSwiIiIilTJTV7yuAva4++vuPgTcC9w1Q8ciIiIiUhEzFbw6gEN5jw9HZSPM7G4ze8rMnuomU9GDExEREbkYZm3nene/x913uPuORmIzfTgiIiIiUzZTwesIsCLv8fKoTERERGTemqng9STQaWZrzCwJvAu4b4aORURERKQi4jPxTd09bWYfAB4AYsBn3P3FmTgWERERkUqZkeAF4O73A/fP1PcXERERqbRZ27leREREZL5R8BIRERGpEAUvERERkQpR8BIRERGpEAUvERERkQpR8BIRERGpEAUvERERkQpR8BIRERGpEAUvERERkQpR8BIRERGpEAUvERERkQpR8BIRERGpEAUvERERkQpR8BIRERGpkPhMH4BMjmP0DSV58QsvcsU10HDDFnrciOX9BN2z/8diM3OMIrNRLHDC/iFSBw7hNS20V28Dot+X6Hcm3VhLT89J6poymE1uv7nft7FlZkx6HyKy8Ch4zQEp+lhJLX09SVp2/QcP7drC6XsGCBimYUkVAO5OS3sVa29cDsubqGmItq2BRHIGD15khl21dSWZDLz3l15l98F6YPRSvwXOcDpg16uNHO+uIvmyE4tlE5V7YXoKfWya8oLFeCykb+laatrh1Kmj0T7yq1l2MXqcH9yGBwKGhyE9nA1tMb0zi8xb+vWeA6qtj7+KAwwBnwWgJ2zk9fAS0seyP8IBatlzfAuPPLeZIarIfUQk6efW29J0/tpWTgdtAHiYXReLQ/tyOHBSf57L/PXRP35vtHSWN3WeLVofhrBjcxe9fYVvh0EQQt6vRmxMx4z8q1qhG4ePVfPEi0Mc3FlDrTse1R8JeRREtdErY7nC7r30vBwysKqT2g4Iog3dC7cjCnPOaHjL/Z9IQG3j6LYiMvsoeM1RDUE3lwdPFJRdz/fpD1N0eSsAvTTwhL+FHz9wCd99YC+wF8g2W8YI2bCjmiXXrmXp0jQAjY0hB4M2GprVVCILRxDA2o6+Ke9n0+qz3HrVcXr7YyNXx8b+HhnF7ZO5OqEbB49Ws/OFcxzeWUPuAlv3/lP0DydGMmDZfZoTGFRtrKd/7SYaW7J1c39ouRdeZcstjqzPjJZbDOoboMeNZNV5nQYRmYCC1zxTHQxQzWEg+ya7gteL6oTEOBiu5Zmn3szPnjqOE2A4A9QwxD46lg9wyfXtxGNO7fpaehuWVfppiMxJZlBXk7ng7besPcuWtYVX5XZ+4yirFnVRnRwq/33JBrcf7l7H6ycXMbTvJEfD0cteI2HNsnErKAiA2eVYkF3KhAGBhfjqNoZal0JVFM76jb4wTXdPOLLZyBW33J6iVS2LQvobl1Jdc96nQGTeU/Cax8wgxUDJdRtjz7OR5wvKhsIEh8I1PHf4Wl66dx0D1LHnkQTtaw4AEDNnxw1JuHYHrYtH38zz/4rWlTKR6RULQupSg9Qkhyes+47LX5ry9xscjnHwdBPPHVrGqT17R8qbLSRzEE6MqR8EXnQlb9+5WnqHdtPSuYiGmuwV9dz7RJTNslcFCzYrfPPoWNxP69Ur6EotIx4vHsww8rhEnzmP9hZPTOIJi1SYgpeMSAbDrAteZR2vErpxKmzj5YOX0xt1SO6ile/s30T3Zx4jZiFB9BYaM2f52gTbr09Rf2veiLHIyLJBTY3eDEVms6pEhs4lp+hccuqC9+EOp87VsPf4Inr7kxheEKsCyz62oHTTaxjCvl2LeOZHvWAvE7PCevld48w8u/e8q2+5vnPtWxex9OplnK1eUnIEOMDQICy64Gcqcv4UvKSkwJy22HHa+N5I2Vlv5PCBVaQpHCa5m0s5dKid5360hPBvHi6xN6NxeZKNG0K2/MZGBuqznfyra2Bxu0Zwicw3ZtBa30dr/YX3nbthw34Gh2Mc66lnOBMU93GzwittBcEucLr7U7z8xhKe/+wJhjIxzHKjVQvrmsHx5DCHUsVNuZnQSCXSrLl6MW1vXl32WMeOgB076AGgqsqpri4xB4ksOPrIk0mrt242xXYVla8I9zJkxT1wc2+KGeIcPrKG5w5fw1MPD4w0A2SIkWCQt9wZp+227JWy3GitVMpZtSrNcGv7xXtCIjKrVSUyrFx05oK27Qh7WNlSeluzElfaStTLuHG8p44XnhnitUdPFg+OyNsov5tFfr10GKM+NUB15xo2renByF6hGw1nVtyMmvs/WqhNZchs3kRSUwPNCwpeMmVNQdeEdZZyhB38hGFPjDQ69Hkde8JNvPDtK3n829kOxY6RJkGcIdbe0M7SjWfwMFs/kQhZ1jbAJbct5Uy1OvyLSHlB4DRUD055P43Vg1Nqdg1D48TZWl47dpZde2sKA9rIshddhQOiJlqne6Ca2Hceo7pzNfU16ZFkFuZtQ95Vt7EjWMNoua46Q3PDEE3XdV7w85Gpm1LwMrNfA/4HsAm4yt2fylv3IeB9QAb4I3d/ICq/Hfg4EAM+5e4fmcoxyNySsNEOwkk7zY7gp+zgpwV1esNa9oUbeOWRy3ntkWoA0sQ5RyNDVNHwr13ULzsCZF9ETXV9bL2mnqpf2E5VanQ/VWn19BeRmRUEzpLGcyxpPHfB+zg7kOTQ6WYGzpyCM4WXx/LnbMtdaQuK+sQ5vUNJevpTvH62nvhDj5f8PgXxr0SraNPmFXSuPMvg+k0X9kQEmPoVrxeAXwH+b36hmW0G3gVsAZYBD5rZhmj1J4C3AoeBJ83sPnef+lAcmTdqg162Bs+wlWcKygfDJId9DYf3r4X92TeJczSyh1U89b1Walf8BMMJ3aiO97N1S8At/20T1dXFASyRcOK63isic0B9aojNy45NeT+Z0DjdW0MmLJxhd7z55XLcYe/RLp7e3cjwdx+nrmqQJ/b2jKmTd9Utr7yxeoBVN66jJnXhU63MJ1P66HH3lwGseA6Bu4B73X0Q2Gdme4CronV73P31aLt7o7oKXjKhqmCIdexmHbsLytMe51i4jN7D2dGXp1jKYVbz9P5lPPadnjFzFmXfZBIMcOfvVHPF25roXRH99WZOW1tIVZU6wIrI/BMLnLb63gvevq2+l8F09mbA5aYOKhjwYNnA9kZ3A4987TTVk5gSpZyhdIzWul423LqqoLzkCPrcY6xoXSqZIZmY2ff4i/U3fweQfy3zcFQGcGhM+dWldmBmdwN3A7SpK5qMI25pOmIHRx4P+Wts9GdwK33flGGSPOfX8L0vrOHrXwgxfgo4ITHaO2NceaWzcsdiEvFsD4raVEjdjrU0NCiQicjCFQROdTJ93tutbu1idevEfYHHMzAc5/nD7bz0vUMF5eUGNZRa3zeUYDgTY8NNHWVHoo5dhtEAl4iHtDYNkohP7bNgwkRjZg8CS0us+rC7f3NK330c7n4PcA9Ap6X0iSeTlrQhknZ63Dpv8W8VlR1nGc/vuYofv7aM9JfOjJQPUkX7xhOsuqSOlrq+kdm5c5zsX5KLG3rZfnsb4ZYt0/AsREQkJ5VIc+WaQxNXHEc6E3Coq4m+586MBLKHvpsu1Z2tcJRr1GcuE8YwC1l3RRtL6s+NGRLByK3CJjJh8HL3Wye1p0JHgBV5j5dHZYxTLlIx+Z38czo4QEfsQFH5q+FWDuxez6FXajlILCqN7lRM9hZMvTTQRx33P9RPKpYdLJAMhrj5ppDW334rzc2jaS0e1wz/IiKVFo+FrGkt/KO8rTrNlYtfmNT2Q5k4XYONvPFKG7uGsl1b8q+yBYTlNi08jkke7/m6D/iSmX2MbOf6TuAJsiGy08zWkA1c7wJ+6yIdg8i02BC8wAbG/8XMeMBpX8zB19aRiX6tznoDn31xI72feJzW9amRv41qY33ceP0w225r4+yqzSP7yF3eTiad+npXOBMRmUWSsTRLak6xpObCpxeBqU8n8cvAPwJtwHfM7Fl3v83dXzSzr5DtNJ8G3u/umWibDwAPkJ0J4DPu/uKUnoHILBCzkDY7ShtHC8rdv8UZb6Hn9ZaRsiPhSr61eyuf/3QSeKygvgFGyOZL+7n+emPxFSsJogAWXtJJa2tILIaIiMxRUx3V+HXg62XW/Q3wNyXK7wfun8r3FZkrzKDZTtPM6OXtVcEeruNh+ryWtMcL6gLs9kvZu2sjn9vVQoafk7vlr3GYS3+xndXbmqmtzjaV5vdNcIeYGY31w2xZ28PQxq0X/wmKiMh50XBBkRlSY70l71OynZ9weazwStgA1TzvV3H0/uXs+07tSKfOgluTECckxtLNNTy6ZjGpRLZ5NL9ubWqYKzcHVCUn1xdBRESml4KXyCwTmBNQOGS7jrNcaw+Nu13oRrc3s//lTk68vIz8qQ0NCD3gOB089mVjw2VOIpa9ambm1MX7uP6Wara8fVXJfYuIyPRQ8BKZJwLzqFlzZ9k6uXD2xnMrGSZ7x91hkrzKcnbubCLxvw4UzYXjGG+6apib3xpn1Y3rCAIvmgMnEQ+nPLeNiMhCoOAlsoCMhrPCIdXu0Ot1nGFRUfDqoZlDT6zjY0+0k/mbn2OERS2kcYa58tpzXHdzDY3bLxkpb25I6zYhIiJ5FLxEBDOos3PUUXwj33Y/xAp7fdztX/Zt7HpsNY8/lgCydZ2AKvq59Oo0l17XSCJWGMBy8S4eC2mt62PlTRsQEZnvFLxEZFyBOXWcHbfOFTzCdvtJQdk5GrMjNHcu4eWdYcnbeWQHBMTpuLyJzft7i2aCdodELGRRXS9vuq2Dhtrzv12JiMhsouAlIlMW2OhM/jmNdHGV/Wjc7XJ9zg49u5Zdz7YWhbMMMc7RwAA1LHn4KHErDl6JIE1j8hzbbmhk2x3LRspL9ThTPzQRmWkKXiIyY8r1OcuXC2cndi0jZPTG5xbd2PwkSzjpDTz1eA320bG3fHIcY/llNWzdUctlt7bSVF94u6j8G+KmkhnqatQnTUQuHgUvEZnVJgpnp72NNDFKTooGDJPg+K4OfvzcOv7j0ycpvhYWECPD+isCNmxvZv3ikwAFzZ6pxDAd128gVaX5z0RkahS8RGROa7ET5TLXiA4Ocpk/zgA1Resco5cG9j+9nu//bC3fJc7YcJYhwZptR7hkeyP1qYGR2zgxpmZNcpj2xh5W39x54U9IROY1BS8RWRACc2roLbmulnMstp9zFT8uaHrM2cdGjj3bwZPPNJAhXtQXbYgq6jhDxzWL+MFAE7Xf2le0j/qqXq57Sy0rb1xfcoqN/O+rG6SLzF8KXiIieUqFnrW8wlp7pew2fV7LQV9Lz85uEhhDecHMyF4V2+uLeOKndfA/99J+Wd3oxj5aryo2RFt1F5uuaWXL2zoAGM7orugi84mCl4jIFNVYLxvt+QnrDXmSU76E/l3FTZ7DJOmilZd8CTsf7Sf42Gsj61rpJ7CQGBk6r6/jrl8xquKlp9bQ1TKR2U3BS0SkQpI2RLsdGrfOkCfppaF4TjOMXurZ+5O1/PVPGrGCEZ6jta67uY8rbl5MdXKoaN+5Wz0l4xlqksNF60Xk4lPwEhGZRZI2RJKTJdct4jgrbS/DniBNYqQ81+fsIOvZ9fASfvpwb8kJa0MCqhjEHW57+ylWXld8t4D8vmY1yWFaavt0FU1kGil4iYjMMQkbJkHxFasNPM+GCZo8z3kDx1jGD767kvC7x8rWc4wMcdZcW0drdRcxy06lkR/MkrFhtt3cTnNNP0GgyWlFJkPBS0RkAamzHuqsh3WUHyyQs88vof+xavaRpNS9AM7Qys97Q/rTjdQk+qFErWQwTE18kDvfmVQ4E0HBS0REylhju8edI+2sN3L2sUYCH/0oMUabPkOMLhrZzTKe/EF2cACUvp0TQEDImuvqueX2KhbV9Y2Uj53iIx4LScQ0ma3MTQpeIiJyQeqtm3q6J5zA9hJ/jnM0Ft3yaaxeGjjxaDuffHRp2T5qO24cJu0Jbrq9FhgdMDBWLqwFgdNWX3r+NpGZoOAlIiIXVcxCGumasF4Tp+mw/WQ8RrrEx9NxOjj4o8V00coLP85Op1EqoEH2Busp+nGHN982SCIoM/0G0Jrq4pJbigcaiFwMCl4iIjKrxCwz0iyZbwWvs8Jen/R+znkDJ1jKk99bRkjVSHkurA1QQy09tFyzjZe+2l1yHx41nlbHB2ivOcnWW1YTVzOnTIGCl4iIzEu5gQRreLXkevds8+bJx9/geIn7eObVpIs2zv7CSn76hWaq4wMl6hhLqk+yrO44W29ZTcw82nJ8gbmm61hgFLxERGRBMoM6suFsIue8gXOPNNBaZn3oxl46eJJlfONbw2WbQHMSDLH5xhR1iT52vLWteH2QoS5VPAmuzH0KXiIiIhOosx7qGCegGSzjEKEbvTQUDCQo5VW/lMM/Os1JlvLogz1FdyoAiDPMlbeGbLq+o6D82JMvlR1UsO1tHRrxOctNKXiZ2UeBXwKGgL3Ae939TLTuQ8D7gAzwR+7+QFR+O/BxIAZ8yt0/MpVjEBERmS0C8+xIzwls5yfjhrNhknT5Il54cBVPPvjGmLVNBY8yxKligARD/LxviNp4diqOUmEOzx5jYM7i6tNsfeuaCY9VptdUr3h9H/iQu6fN7G+BDwF/YWabgXcBW4BlwINmlhsy8gngrcBh4Ekzu8/dX5ricYiIiMwZ5QYQ5CQYpsZ66eDgpPZ3zhs47a3s/2EaJ6Bc7zLHGKCGOrqpvvoydn25r6hOTXyAjtrjvOmWlaQSpUeDyoWbUvBy9+/lPXwc+NVo+S7gXncfBPaZ2R7gqmjdHnd/HcDM7o3qKniJiIhcoNxAgpVMPOozdOMsTXTvPMkwsaL1R2hkF4u5/zt9BOOEQ4AA54pbnMXVXWy4cS1mXn5utbzlVCK9YJtEp7OP1+8DX46WO8gGsZzDURnAoTHlV5famZndDdwN0KauaCIiItMiMKeRLhqt/NxquXA2SGrcffXQzO6HGniOer717XPjBjUnIEU/m26qIQic7W9pzVtXHNYaUgPzcoDBhInGzB4ElpZY9WF3/2ZU58NAGvjidB2Yu98D3APQaSnd4EtERKRCcuFsIov8OP1WO6l9hgR008KBH7bQRRtPP3yiYP3YkaAhAauva6Sj9hjJMhPg5qTig2y9eSXVydnfNDph8HL3W8dbb2bvAe4EbnEfuaPWEWBFXrXlURnjlIuIiMgcErPM+KM9x2jgDCvsdTI+/qhPMM7RwOlH23iaZYQlmkTzDdPMd79zlvVvrh+9YXuZJk+ARJDGDM4ON0762KfLVEc13g78OXCju+f30LsP+JKZfYxs5/pO4Amyd2foNLM1ZAPXu4DfmsoxiIiIyNwSs4n7d+WaQ8tNgJsv4zG6aeH0T1vpKtM8mothg6QwnCQDxK9ezOmB0fBVqnmtNt5PKj59TZ5T7Tz1T0AV8H3LTr37uLv/gbu/aGZfIdtpPg28390zAGb2AeABstNJfMbdX5ziMYiIiMgCFrMMLZygxU5MXBkY8iRnWMTgE4/w7Dj1MsTp9haqrZc6usedGNdwtr2zgbroilvZeqOtg7NXp6X87+OrZvowREREZAEa8GrOUT9uHSfgkK+jyU7xR5n7fubuO0rV03BBERERkXGkrJ8U41/JAqine8K7Fih4iYiIiEyDlE0cziYaViAiIiIi00TBS0RERKRCFLxEREREKkTBS0RERKRCFLxEREREKkTBS0RERKRCFLxEREREKkTBS0RERKRCFLxEREREKmRO3KvRzM4Cu2f6OGaBVuDkTB/ELKDzoHOQo/OQpfOgc5Cj85A10+dhlbu3lVoxV24ZtLvczSYXEjN7SudB5wF0DnJ0HrJ0HnQOcnQesmbzeVBTo4iIiEiFKHiJiIiIVMhcCV73zPQBzBI6D1k6DzoHOToPWToPOgc5Og9Zs/Y8zInO9SIiIiLzwVy54iUiIiIy5yl4iYiIiFTIrAteZvZRM3vFzHaZ2dfNrClv3YfMbI+Z7Taz2/LKb4/K9pjZB2fkwC+yhfAcAcxshZn9wMxeMrMXzeyPo/IWM/u+mb0W/d8clZuZ/UN0XnaZ2faZfQbTx8xiZvaMmX07erzGzHZGz/XLZpaMyquix3ui9atn9MCnkZk1mdlXo/eEl83s2gX6Wvgv0e/DC2b2b2aWWgivBzP7jJkdN7MX8srO++dvZu+O6r9mZu+eiedyocqcgwX3OVnqPOSt+1MzczNrjR7P7teCu8+qL+BtQDxa/lvgb6PlzcBzQBWwBtgLxKKvvcBaIBnV2TzTz2Oaz8m8f455z7Ud2B4t1wOvRj/7/w18MCr/YN7r4g7gPwADrgF2zvRzmMZz8V+BLwHfjh5/BXhXtPzPwH+Olv8Q+Odo+V3Al2f62KfxHHwO+E/RchJoWmivBaAD2AdU570O3rMQXg/ALwDbgRfyys7r5w+0AK9H/zdHy80z/dymeA4W3OdkqfMQla8AHgAOAK1z4bUw6654ufv33D0dPXwcWB4t3wXc6+6D7r4P2ANcFX3tcffX3X0IuDeqO58shOcIgLu/4e5PR8tngZfJfvDcRfZDmOj/d0bLdwGf96zHgSYza6/sUU8/M1sO/CLwqeixATcDX42qjD0HuXPzVeCWqP6cZmaNZN9sPw3g7kPufoYF9lqIxIFqM4sDNcAbLIDXg7v/GDg9pvh8f/63Ad9399Pu3gV8H7j9oh/8NCl1Dhbi52SZ1wLA3wF/DuSPFJzVr4VZF7zG+H2yqRWyH76H8tYdjsrKlc8nC+E5FomaSLYBO4El7v5GtOoosCRanq/n5u/JvpmE0eNFwJm8N9v85zlyDqL13VH9uW4NcAL4bNTk+ikzq2WBvRbc/Qjwf4CDZANXN/AzFt7rIed8f/7z8nWRZ8F+TprZXcARd39uzKpZfR5mJHiZ2YNRX4WxX3fl1fkwkAa+OBPHKDPLzOqAfwf+xN178td59prxvJ0HxczuBI67+89m+lhmWJxs08In3X0b0Eu2aWnEfH8tAER9mO4iG0SXAbXMoSs2F9NC+PmPZyF/TppZDfCXwF/N9LGcrxm5V6O73zreejN7D3AncEv0iwVwhGxbbs7yqIxxyueL8Z77vGNmCbKh64vu/rWo+JiZtbv7G9El4+NR+Xw8N28G3mFmdwApoAH4ONnL5fHoKkb+88ydg8NRU1QjcKryhz3tDgOH3X1n9PirZIPXQnotANwK7HP3EwBm9jWyr5GF9nrIOd+f/xHgpjHlP6zAcV5U+pxkHdk/Rp6LWtKXA0+b2VXM8tfCrGtqNLPbyTaxvMPd+/JW3Qe8KxqxswboBJ4AngQ6oxE+SbKdSe+r9HFfZAvhOQIjfZk+Dbzs7h/LW3UfkBuB8m7gm3nlvxeNYrkG6M5rhpiT3P1D7r7c3VeT/Vk/7O6/DfwA+NWo2thzkDs3vxrVn/NXAdz9KHDIzC6Jim4BXmIBvRYiB4FrzKwm+v3InYcF9XrIc74//weAt5lZc3T18G1R2Zylz0lw9+fdfbG7r47eKw+THZh1lNn+Wqh0b/6Jvsh2BjwEPBt9/XPeug+THZmxG3h7XvkdZEe/7QU+PNPP4SKdl3n/HKPneT3ZpoNdea+BO8j2UXkIeA14EGiJ6hvwiei8PA/smOnnMM3n4yZGRzWuJfsmugf4f0BVVJ6KHu+J1q+d6eOexud/OfBU9Hr4BtmRSAvutQD8NfAK8ALwr2RHrc371wPwb2T7tQ2T/WB934X8/Mn2g9oTfb13pp/XNJyDBfc5Weo8jFm/n9FRjbP6taBbBomIiIhUyKxrahQRERGZrxS8RERERCpEwUtERESkQhS8RERERCpEwUtERESkQhS8RERERCpEwUtERESkQv4/md4tCFgV+akAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -435,26 +430,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -485,7 +476,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.12.1" }, "orig_nbformat": 4 }, diff --git a/examples/01_opening_floris_computing_power.py b/examples/01_opening_floris_computing_power.py index 59372a866..dcb1987c1 100644 --- a/examples/01_opening_floris_computing_power.py +++ b/examples/01_opening_floris_computing_power.py @@ -1,79 +1,62 @@ +"""Example 1: Opening FLORIS and Computing Power -import numpy as np - -from floris.tools import FlorisInterface +This first example illustrates several of the key concepts in FLORIS. It: - -""" -This example creates a FLORIS instance -1) Makes a two-turbine layout -2) Demonstrates single ws/wd simulations -3) Demonstrates mulitple ws/wd simulations + 1) Initializing FLORIS + 2) Changing the wind farm layout + 3) Changing the incoming wind speed, wind direction and turbulence intensity + 4) Running the FLORIS simulation + 5) Getting the power output of the turbines Main concept is introduce FLORIS and illustrate essential structure of most-used FLORIS calls """ -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") -# Convert to a simple two turbine layout -fi.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) +import numpy as np -# Single wind speed and wind direction -print("\n========================= Single Wind Direction and Wind Speed =========================") +from floris import FlorisModel -# Get the turbine powers assuming 1 wind direction and speed -# Set the yaw angles to 0 with 1 wind direction and speed -fi.set(wind_directions=[270.0], wind_speeds=[8.0], yaw_angles=np.zeros([1, 2])) -fi.run() +# Initialize FLORIS with the given input file. +# The Floris class is the entry point for most usage. +fmodel = FlorisModel("inputs/gch.yaml") -# Get the turbine powers -turbine_powers = fi.get_turbine_powers() / 1000.0 +# Changing the wind farm layout uses FLORIS' set method to a two-turbine layout +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) -print("The turbine power matrix should be of dimensions 1 findex X 2 Turbines") -print(turbine_powers) -print("Shape: ", turbine_powers.shape) +# Changing wind speed, wind direction, and turbulence intensity using the set method +# as well. Note that the wind_speeds, wind_directions, and turbulence_intensities +# are all specified as arrays of the same length. +fmodel.set(wind_directions=np.array([270.0]), + wind_speeds=[8.0], + turbulence_intensities=np.array([0.06])) -# Single wind speed and multiple wind directions -print("\n========================= Single Wind Direction and Multiple Wind Speeds ===============") - -wind_speeds = np.array([8.0, 9.0, 10.0]) -wind_directions = np.array([270.0, 270.0, 270.0]) -turbulence_intensities = np.array([0.06, 0.06, 0.06]) - -# 3 wind directions/ speeds -fi.set( - wind_speeds=wind_speeds, - wind_directions=wind_directions, - turbulence_intensities=turbulence_intensities, - yaw_angles=np.zeros([3, 2]) -) -fi.run() -turbine_powers = fi.get_turbine_powers() / 1000.0 -print("The turbine power matrix should be of dimensions 3 findex X 2 Turbines") -print(turbine_powers) -print("Shape: ", turbine_powers.shape) +# Note that typically all 3, wind_directions, wind_speeds and turbulence_intensities +# must be supplied to set. However, the exception is if not changing the lenght +# of the arrays, then only one or two may be supplied. +fmodel.set(turbulence_intensities=np.array([0.07])) -# Multiple wind speeds and multiple wind directions -print("\n========================= Multiple Wind Directions and Multiple Wind Speeds ============") +# The number of elements in the wind_speeds, wind_directions, and turbulence_intensities +# corresponds to the number of conditions to be simulated. In FLORIS, each of these are +# tracked by a simple index called a findex. There is no requirement that the values +# be unique. Internally in FLORIS, most data structures will have the findex as their +# 0th dimension. The value n_findex is the total number of conditions to be simulated. +# This command would simulate 4 conditions (n_findex = 4). +fmodel.set(wind_directions=np.array([270.0, 270.0, 270.0, 270.0]), + wind_speeds=[8.0, 8.0, 10.0, 10.0], + turbulence_intensities=np.array([0.06, 0.06, 0.06, 0.06])) -# To consider each combination, this needs to be broadcast out in advance +# After the set method, the run method is called to perform the simulation +fmodel.run() -wind_speeds = np.tile([8.0, 9.0, 10.0], 3) -wind_directions = np.repeat([260.0, 270.0, 280.0], 3) -turbulence_intensities = np.tile([0.06, 0.06, 0.06], 3) +# There are functions to get either the power of each turbine, or the farm power +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +farm_power = fmodel.get_farm_power() / 1000.0 -fi.set( - wind_directions=wind_directions, - wind_speeds=wind_speeds, - turbulence_intensities=turbulence_intensities, - yaw_angles=np.zeros([9, 2]) -) -fi.run() -turbine_powers = fi.get_turbine_powers() / 1000.0 -print("The turbine power matrix should be of dimensions 9 WD/WS X 2 Turbines") +print("The turbine power matrix should be of dimensions 4 (n_findex) X 2 (n_turbines)") print(turbine_powers) print("Shape: ", turbine_powers.shape) + +print("The farm power should be a 1D array of length 4 (n_findex)") +print(farm_power) +print("Shape: ", farm_power.shape) diff --git a/examples/02_visualizations.py b/examples/02_visualizations.py index f7e8c8ea6..de526328f 100644 --- a/examples/02_visualizations.py +++ b/examples/02_visualizations.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -import floris.tools.flow_visualization as flowviz -from floris.tools import FlorisInterface +import floris.flow_visualization as flowviz +from floris import FlorisModel """ @@ -12,7 +12,7 @@ we are plotting three slices of the resulting flow field: 1. Horizontal slice parallel to the ground and located at the hub height 2. Vertical slice of parallel with the direction of the wind -3. Veritical slice parallel to to the turbine disc plane +3. Vertical slice parallel to to the turbine disc plane Additionally, an alternative method of plotting a horizontal slice is shown. Rather than calculating points in the domain behind a turbine, @@ -21,36 +21,36 @@ rotor. """ -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive +# Initialize FLORIS with the given input file via FlorisModel. +# For basic usage, FlorisModel provides a simplified and expressive # entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") # The rotor plots show what is happening at each turbine, but we do not # see what is happening between each turbine. For this, we use a # grid that has points regularly distributed throughout the fluid domain. -# The FlorisInterface contains functions for configuring the new grid, +# The FlorisModel contains functions for configuring the new grid, # running the simulation, and generating plots of 2D slices of the # flow field. # Note this visualization grid created within the calculate_horizontal_plane function will be reset # to what existed previously at the end of the function -# Using the FlorisInterface functions, get 2D slices. -horizontal_plane = fi.calculate_horizontal_plane( +# Using the FlorisModel functions, get 2D slices. +horizontal_plane = fmodel.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=90.0, yaw_angles=np.array([[25.,0.,0.]]), ) -y_plane = fi.calculate_y_plane( +y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=0.0, yaw_angles=np.array([[25.,0.,0.]]), ) -cross_plane = fi.calculate_cross_plane( +cross_plane = fmodel.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=630.0, @@ -82,7 +82,7 @@ # Some wake models may not yet have a visualization method included, for these cases can use # a slower version which scans a turbine model to produce the horizontal flow horizontal_plane_scan_turbine = flowviz.calculate_horizontal_plane_with_turbines( - fi, + fmodel, x_resolution=20, y_resolution=10, yaw_angles=np.array([[25.,0.,0.]]), @@ -101,11 +101,11 @@ # Run the wake calculation to get the turbine-turbine interfactions # on the turbine grids -fi.run() +fmodel.run() # Plot the values at each rotor fig, axes, _ , _ = flowviz.plot_rotor_values( - fi.floris.flow_field.u, + fmodel.core.flow_field.u, findex=0, n_rows=1, n_cols=3, @@ -125,15 +125,15 @@ "type": "turbine_grid", "turbine_grid_points": 10 } -fi.set(solver_settings=solver_settings) +fmodel.set(solver_settings=solver_settings) # Run the wake calculation to get the turbine-turbine interfactions # on the turbine grids -fi.run() +fmodel.run() # Plot the values at each rotor fig, axes, _ , _ = flowviz.plot_rotor_values( - fi.floris.flow_field.u, + fmodel.core.flow_field.u, findex=0, n_rows=1, n_cols=3, diff --git a/examples/03_making_adjustments.py b/examples/03_making_adjustments.py index a17eb3396..0bac6e98b 100644 --- a/examples/03_making_adjustments.py +++ b/examples/03_making_adjustments.py @@ -2,9 +2,9 @@ import matplotlib.pyplot as plt import numpy as np -import floris.tools.flow_visualization as flowviz -import floris.tools.layout_visualization as layoutviz -from floris.tools import FlorisInterface +import floris.flow_visualization as flowviz +import floris.layout_visualization as layoutviz +from floris import FlorisModel """ @@ -20,12 +20,12 @@ MIN_WS = 1.0 MAX_WS = 8.0 -# Initialize FLORIS with the given input file via FlorisInterface -fi = FlorisInterface("inputs/gch.yaml") +# Initialize FLORIS with the given input file via FlorisModel +fmodel = FlorisModel("inputs/gch.yaml") # Plot a horizatonal slice of the initial configuration -horizontal_plane = fi.calculate_horizontal_plane(height=90.0) +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0) flowviz.visualize_cut_plane( horizontal_plane, ax=axarr[0], @@ -35,7 +35,7 @@ ) # Change the wind speed -horizontal_plane = fi.calculate_horizontal_plane(ws=[7.0], height=90.0) +horizontal_plane = fmodel.calculate_horizontal_plane(ws=[7.0], height=90.0) flowviz.visualize_cut_plane( horizontal_plane, ax=axarr[1], @@ -46,8 +46,8 @@ # Change the wind shear, reset the wind speed, and plot a vertical slice -fi.set(wind_shear=0.2, wind_speeds=[8.0]) -y_plane = fi.calculate_y_plane(crossstream_dist=0.0) +fmodel.set(wind_shear=0.2, wind_speeds=[8.0]) +y_plane = fmodel.calculate_y_plane(crossstream_dist=0.0) flowviz.visualize_cut_plane( y_plane, ax=axarr[2], @@ -59,11 +59,11 @@ # # Change the farm layout N = 3 # Number of turbines per row and per column X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters[0,0] * np.arange(0, N, 1), - 5.0 * fi.floris.farm.rotor_diameters[0,0] * np.arange(0, N, 1), + 5.0 * fmodel.core.farm.rotor_diameters[0,0] * np.arange(0, N, 1), + 5.0 * fmodel.core.farm.rotor_diameters[0,0] * np.arange(0, N, 1), ) -fi.set(layout_x=X.flatten(), layout_y=Y.flatten(), wind_directions=[270.0]) -horizontal_plane = fi.calculate_horizontal_plane(height=90.0) +fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten(), wind_directions=[270.0]) +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0) flowviz.visualize_cut_plane( horizontal_plane, ax=axarr[3], @@ -71,8 +71,8 @@ min_speed=MIN_WS, max_speed=MAX_WS ) -layoutviz.plot_turbine_labels(fi, axarr[3],plotting_dict={'color':"w"})#, backgroundcolor="k") -layoutviz.plot_turbine_rotors(fi, axarr[3]) +layoutviz.plot_turbine_labels(fmodel, axarr[3], plotting_dict={'color':"w"}) #, backgroundcolor="k") +layoutviz.plot_turbine_rotors(fmodel, axarr[3]) # Change the yaw angles and configure the plot differently yaw_angles = np.zeros((1, N * N)) @@ -87,7 +87,7 @@ yaw_angles[:,4] = 30.0 yaw_angles[:,7] = -30.0 -horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles, height=90.0) +horizontal_plane = fmodel.calculate_horizontal_plane(yaw_angles=yaw_angles, height=90.0) flowviz.visualize_cut_plane( horizontal_plane, ax=axarr[4], @@ -96,11 +96,11 @@ min_speed=MIN_WS, max_speed=MAX_WS ) -layoutviz.plot_turbine_rotors(fi, axarr[4], yaw_angles=yaw_angles, color="c") +layoutviz.plot_turbine_rotors(fmodel, axarr[4], yaw_angles=yaw_angles, color="c") # Plot the cross-plane of the 3x3 configuration -cross_plane = fi.calculate_cross_plane(yaw_angles=yaw_angles, downstream_dist=610.0) +cross_plane = fmodel.calculate_cross_plane(yaw_angles=yaw_angles, downstream_dist=610.0) flowviz.visualize_cut_plane( cross_plane, ax=axarr[5], diff --git a/examples/04_sweep_wind_directions.py b/examples/04_sweep_wind_directions.py index a06892e16..d049a0772 100644 --- a/examples/04_sweep_wind_directions.py +++ b/examples/04_sweep_wind_directions.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -16,19 +16,19 @@ """ # Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 # Define a two turbine farm D = 126. layout_x = np.array([0, D*6]) layout_y = [0, 0] -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # Sweep wind speeds but keep wind direction fixed wd_array = np.arange(250,291,1.) ws_array = 8.0 * np.ones_like(wd_array) ti_array = 0.06 * np.ones_like(wd_array) -fi.set(wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array) +fmodel.set(wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array) # Define a matrix of yaw angles to be all 0 # Note that yaw angles is now specified as a matrix whose dimensions are @@ -38,13 +38,13 @@ n_findex = num_wd # Could be either num_wd or num_ws num_turbine = len(layout_x) # Number of turbines yaw_angles = np.zeros((n_findex, num_turbine)) -fi.set(yaw_angles=yaw_angles) +fmodel.set(yaw_angles=yaw_angles) # Calculate -fi.run() +fmodel.run() # Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1E3 # In kW +turbine_powers = fmodel.get_turbine_powers() / 1E3 # In kW # Pull out the power values per turbine pow_t0 = turbine_powers[:,0].flatten() diff --git a/examples/05_sweep_wind_speeds.py b/examples/05_sweep_wind_speeds.py index a9dbc979c..e5cd07c3a 100644 --- a/examples/05_sweep_wind_speeds.py +++ b/examples/05_sweep_wind_speeds.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -16,19 +16,19 @@ # Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 # Define a two turbine farm D = 126. layout_x = np.array([0, D*6]) layout_y = [0, 0] -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # Sweep wind speeds but keep wind direction fixed ws_array = np.arange(5,25,0.5) wd_array = 270.0 * np.ones_like(ws_array) ti_array = 0.06 * np.ones_like(ws_array) -fi.set(wind_directions=wd_array,wind_speeds=ws_array, turbulence_intensities=ti_array) +fmodel.set(wind_directions=wd_array,wind_speeds=ws_array, turbulence_intensities=ti_array) # Define a matrix of yaw angles to be all 0 # Note that yaw angles is now specified as a matrix whose dimensions are @@ -38,13 +38,13 @@ n_findex = num_wd # Could be either num_wd or num_ws num_turbine = len(layout_x) yaw_angles = np.zeros((n_findex, num_turbine)) -fi.set(yaw_angles=yaw_angles) +fmodel.set(yaw_angles=yaw_angles) # Calculate -fi.run() +fmodel.run() # Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1E3 # In kW +turbine_powers = fmodel.get_turbine_powers() / 1E3 # In kW # Pull out the power values per turbine pow_t0 = turbine_powers[:,0].flatten() diff --git a/examples/06_sweep_wind_conditions.py b/examples/06_sweep_wind_conditions.py index dd1756685..e9f42487b 100644 --- a/examples/06_sweep_wind_conditions.py +++ b/examples/06_sweep_wind_conditions.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -20,14 +20,14 @@ """ # Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +# fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Define a 5 turbine farm D = 126.0 layout_x = np.array([0, D*6, D*12, D*18, D*24]) layout_y = [0, 0, 0, 0, 0] -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # In this case we want to check a grid of wind speed and direction combinations wind_speeds_to_expand = np.arange(6, 9, 1.0) @@ -47,7 +47,7 @@ turbulence_intensities = 0.06 * np.ones_like(wd_array) # Now reinitialize FLORIS -fi.set( +fmodel.set( wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=turbulence_intensities @@ -61,13 +61,13 @@ n_findex = num_wd # Could be either num_wd or num_ws num_turbine = len(layout_x) yaw_angles = np.zeros((n_findex, num_turbine)) -fi.set(yaw_angles=yaw_angles) +fmodel.set(yaw_angles=yaw_angles) # Calculate -fi.run() +fmodel.run() # Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1e3 # In kW +turbine_powers = fmodel.get_turbine_powers() / 1e3 # In kW # Show results by ws and wd fig, axarr = plt.subplots(num_unique_ws, 1, sharex=True, sharey=True, figsize=(6, 10)) diff --git a/examples/07_calc_aep_from_rose.py b/examples/07_calc_aep_from_rose.py index 116f6f1cd..cc2de88d4 100644 --- a/examples/07_calc_aep_from_rose.py +++ b/examples/07_calc_aep_from_rose.py @@ -3,15 +3,15 @@ import pandas as pd from scipy.interpolate import NearestNDInterpolator -from floris.tools import FlorisInterface +from floris import FlorisModel """ This example demonstrates how to calculate the Annual Energy Production (AEP) of a wind farm using wind rose information stored in a .csv file. -The wind rose information is first loaded, after which we initialize our Floris -Interface. A 3 turbine farm is generated, and then the turbine wakes and powers +The wind rose information is first loaded, after which we initialize our FlorisModel. +A 3 turbine farm is generated, and then the turbine wakes and powers are calculated across all the wind directions. Finally, the farm power is converted to AEP and reported out. """ @@ -42,13 +42,13 @@ freq = freq / np.sum(freq) # Load the FLORIS object -fi = FlorisInterface("inputs/gch.yaml") # GCH model -# fi = FlorisInterface("inputs/cc.yaml") # CumulativeCurl model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model +# fmodel = FlorisModel("inputs/cc.yaml") # CumulativeCurl model # Assume a three-turbine wind farm with 5D spacing. We reinitialize the # floris object and assign the layout, wind speed and wind direction arrays. -D = fi.floris.farm.rotor_diameters[0] # Rotor diameter for the NREL 5 MW -fi.set( +D = fmodel.core.farm.rotor_diameters[0] # Rotor diameter for the NREL 5 MW +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wind_directions, @@ -57,7 +57,7 @@ ) # Compute the AEP using the default settings -aep = fi.get_farm_AEP(freq=freq) +aep = fmodel.get_farm_AEP(freq=freq) print("Farm AEP (default options): {:.3f} GWh".format(aep / 1.0e9)) # Compute the AEP again while specifying a cut-in and cut-out wind speed. @@ -66,7 +66,7 @@ # prevent unexpected behavior for zero/negative and very high wind speeds. # In this example, the results should not change between this and the default # call to 'get_farm_AEP()'. -aep = fi.get_farm_AEP( +aep = fmodel.get_farm_AEP( freq=freq, cut_in_wind_speed=3.0, # Wakes are not evaluated below this wind speed cut_out_wind_speed=25.0, # Wakes are not evaluated above this wind speed @@ -76,5 +76,5 @@ # Finally, we can also compute the AEP while ignoring all wake calculations. # This can be useful to quantity the annual wake losses in the farm. Such # calculations can be facilitated by enabling the 'no_wake' handle. -aep_no_wake = fi.get_farm_AEP(freq, no_wake=True) +aep_no_wake = fmodel.get_farm_AEP(freq, no_wake=True) print("Farm AEP (no_wake=True): {:.3f} GWh".format(aep_no_wake / 1.0e9)) diff --git a/examples/09_compare_farm_power_with_neighbor.py b/examples/09_compare_farm_power_with_neighbor.py index 48c02ff8d..59e16f841 100644 --- a/examples/09_compare_farm_power_with_neighbor.py +++ b/examples/09_compare_farm_power_with_neighbor.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -18,19 +18,19 @@ # Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 # Define a 4 turbine farm turbine farm D = 126. layout_x = np.array([0, D*6, 0, D*6]) layout_y = [0, 0, D*3, D*3] -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # Define a simple wind rose with just 1 wind speed wd_array = np.arange(0,360,4.) ws_array = 8.0 * np.ones_like(wd_array) turbulence_intensities = 0.06 * np.ones_like(wd_array) -fi.set( +fmodel.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities @@ -38,25 +38,25 @@ # Calculate -fi.run() +fmodel.run() # Collect the farm power -farm_power_base = fi.get_farm_power() / 1E3 # In kW +farm_power_base = fmodel.get_farm_power() / 1E3 # In kW # Add a neighbor to the east layout_x = np.array([0, D*6, 0, D*6, D*12, D*15, D*12, D*15]) layout_y = np.array([0, 0, D*3, D*3, 0, 0, D*3, D*3]) -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # Define the weights to exclude the neighboring farm from calcuations of power turbine_weights = np.zeros(len(layout_x), dtype=int) turbine_weights[0:4] = 1.0 # Calculate -fi.run() +fmodel.run() # Collect the farm power with the neightbor -farm_power_neighbor = fi.get_farm_power(turbine_weights=turbine_weights) / 1E3 # In kW +farm_power_neighbor = fmodel.get_farm_power(turbine_weights=turbine_weights) / 1E3 # In kW # Show the farms fig, ax = plt.subplots() diff --git a/examples/10_opt_yaw_single_ws.py b/examples/10_opt_yaw_single_ws.py index fb3b534b0..f33878c9e 100644 --- a/examples/10_opt_yaw_single_ws.py +++ b/examples/10_opt_yaw_single_ws.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR """ @@ -16,25 +16,25 @@ """ # Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +# fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Reinitialize as a 3-turbine farm with range of WDs and 1 WS wd_array = np.arange(0.0, 360.0, 3.0) ws_array = 8.0 * np.ones_like(wd_array) turbulence_intensities = 0.06 * np.ones_like(wd_array) D = 126.0 # Rotor diameter for the NREL 5 MW -fi.set( +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities, ) -print(fi.floris.farm.rotor_diameters) +print(fmodel.core.farm.rotor_diameters) # Initialize optimizer object and run optimization using the Serial-Refine method -yaw_opt = YawOptimizationSR(fi) +yaw_opt = YawOptimizationSR(fmodel) df_opt = yaw_opt.optimize() print("Optimization results:") diff --git a/examples/11_opt_yaw_multiple_ws.py b/examples/11_opt_yaw_multiple_ws.py index f0ee51e14..0a7d9668a 100644 --- a/examples/11_opt_yaw_multiple_ws.py +++ b/examples/11_opt_yaw_multiple_ws.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR """ @@ -16,8 +16,8 @@ """ # Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +# fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Define arrays of ws/wd wind_speeds_to_expand = np.arange(2.0, 18.0, 1.0) @@ -36,7 +36,7 @@ # Reinitialize as a 3-turbine farm with range of WDs and WSs D = 126.0 # Rotor diameter for the NREL 5 MW -fi.set( +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, @@ -55,7 +55,7 @@ # but has no effect on the predicted power uplift from wake steering. # Hence, it should mostly be used when actually synthesizing a practicable # wind farm controller. -yaw_opt = YawOptimizationSR(fi) +yaw_opt = YawOptimizationSR(fmodel) df_opt = yaw_opt.optimize() print("Optimization results:") @@ -74,7 +74,7 @@ figsize=(10, 8) ) jj = 0 -for ii, ws in enumerate(np.unique(fi.floris.flow_field.wind_speeds)): +for ii, ws in enumerate(np.unique(fmodel.core.flow_field.wind_speeds)): xi = np.remainder(ii, 4) if ((ii > 0) & (xi == 0)): jj += 1 @@ -104,7 +104,7 @@ figsize=(10, 8) ) jj = 0 -for ii, ws in enumerate(np.unique(fi.floris.flow_field.wind_speeds)): +for ii, ws in enumerate(np.unique(fmodel.core.flow_field.wind_speeds)): xi = np.remainder(ii, 4) if ((ii > 0) & (xi == 0)): jj += 1 diff --git a/examples/12_optimize_yaw.py b/examples/12_optimize_yaw.py index 41d7f23e2..d631d5437 100644 --- a/examples/12_optimize_yaw.py +++ b/examples/12_optimize_yaw.py @@ -5,8 +5,8 @@ import numpy as np import pandas as pd -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR """ @@ -26,18 +26,18 @@ def load_floris(): # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model + fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 + # fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Specify wind farm layout and update in the floris object N = 5 # number of turbines per row and per column X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), - 5.0 * fi.floris.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 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), ) - fi.set(layout_x=X.flatten(), layout_y=Y.flatten()) + fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten()) - return fi + return fmodel def load_windrose(): @@ -49,11 +49,11 @@ def load_windrose(): return df -def calculate_aep(fi, df_windrose, column_name="farm_power"): +def calculate_aep(fmodel, df_windrose, column_name="farm_power"): from scipy.interpolate import NearestNDInterpolator # Define columns - nturbs = len(fi.layout_x) + nturbs = len(fmodel.layout_x) yaw_cols = ["yaw_{:03d}".format(ti) for ti in range(nturbs)] if "yaw_000" not in df_windrose.columns: @@ -64,7 +64,7 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): ws_array = np.array(df_windrose["ws"], dtype=float) turbulence_intensities = 0.06 * np.ones_like(wd_array) yaw_angles = np.array(df_windrose[yaw_cols], dtype=float) - fi.set( + fmodel.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities, @@ -72,8 +72,8 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): ) # Calculate FLORIS for every WD and WS combination and get the farm power - fi.run() - farm_power_array = fi.get_farm_power() + fmodel.run() + farm_power_array = fmodel.get_farm_power() # Now map FLORIS solutions to dataframe interpolant = NearestNDInterpolator( @@ -94,17 +94,17 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): df_windrose = load_windrose() # Load FLORIS - fi = load_floris() - ws_array = 8.0 * np.ones_like(fi.floris.flow_field.wind_directions) - fi.set(wind_speeds=ws_array) - nturbs = len(fi.layout_x) + fmodel = load_floris() + ws_array = 8.0 * np.ones_like(fmodel.core.flow_field.wind_directions) + fmodel.set(wind_speeds=ws_array) + nturbs = len(fmodel.layout_x) # First, get baseline AEP, without wake steering start_time = timerpc() print(" ") print("===========================================================") print("Calculating baseline annual energy production (AEP)...") - aep_bl = calculate_aep(fi, df_windrose, "farm_power_baseline") + aep_bl = calculate_aep(fmodel, df_windrose, "farm_power_baseline") t = timerpc() - start_time print("Baseline AEP: {:.3f} GWh. Time spent: {:.1f} s.".format(aep_bl, t)) print("===========================================================") @@ -116,13 +116,13 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): wd_array = np.arange(0.0, 360.0, 5.0) ws_array = 8.0 * np.ones_like(wd_array) turbulence_intensities = 0.06 * np.ones_like(wd_array) - fi.set( + fmodel.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities, ) yaw_opt = YawOptimizationSR( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=0.0, # Allowable yaw angles lower bound maximum_yaw_angle=20.0, # Allowable yaw angles upper bound Ny_passes=[5, 4], @@ -132,7 +132,7 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): df_opt = yaw_opt.optimize() end_time = timerpc() t_tot = end_time - start_time - t_fi = yaw_opt.time_spent_in_floris + t_fmodel = yaw_opt.time_spent_in_floris print("Optimization finished in {:.2f} seconds.".format(t_tot)) print(" ") @@ -171,7 +171,7 @@ def calculate_aep(fi, df_windrose, column_name="farm_power"): start_time = timerpc() print("==================================================================") print("Calculating annual energy production (AEP) with wake steering...") - aep_opt = calculate_aep(fi, df_windrose, "farm_power_opt") + aep_opt = calculate_aep(fmodel, df_windrose, "farm_power_opt") aep_uplift = 100.0 * (aep_opt / aep_bl - 1) t = timerpc() - start_time print("Optimal AEP: {:.3f} GWh. Time spent: {:.1f} s.".format(aep_opt, t)) diff --git a/examples/12_optimize_yaw_in_parallel.py b/examples/12_optimize_yaw_in_parallel.py index 74461ce94..ac57f8548 100644 --- a/examples/12_optimize_yaw_in_parallel.py +++ b/examples/12_optimize_yaw_in_parallel.py @@ -4,7 +4,7 @@ import pandas as pd from scipy.interpolate import LinearNDInterpolator -from floris.tools import FlorisInterface, ParallelComputingInterface +from floris import FlorisModel, ParallelComputingInterface """ @@ -14,18 +14,18 @@ def load_floris(): # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model + fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 + # fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Specify wind farm layout and update in the floris object N = 4 # number of turbines per row and per column X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), - 5.0 * fi.floris.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 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), ) - fi.set(layout_x=X.flatten(), layout_y=Y.flatten()) + fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten()) - return fi + return fmodel def load_windrose(): @@ -43,7 +43,7 @@ def load_windrose(): df_windrose, windrose_interpolant = load_windrose() # Load a FLORIS object for AEP calculations - fi_aep = load_floris() + fmodel_aep = load_floris() # Define arrays of wd/ws wind_directions_to_expand = np.arange(0.0, 360.0, 1.0) @@ -60,7 +60,7 @@ def load_windrose(): ws_array = wind_speeds_grid.flatten() turbulence_intensities = 0.08 * np.ones_like(wd_array) - fi_aep.set( + fmodel_aep.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities, @@ -68,8 +68,8 @@ def load_windrose(): # Pour this into a parallel computing interface parallel_interface = "concurrent" - fi_aep_parallel = ParallelComputingInterface( - fi=fi_aep, + fmodel_aep_parallel = ParallelComputingInterface( + fmodel=fmodel_aep, max_workers=max_workers, n_wind_condition_splits=max_workers, interface=parallel_interface, @@ -81,11 +81,11 @@ def load_windrose(): freq_grid = freq_grid / np.sum(freq_grid) # Normalize to 1.0 # Calculate farm power baseline - farm_power_bl = fi_aep_parallel.get_farm_power() + farm_power_bl = fmodel_aep_parallel.get_farm_power() aep_bl = np.sum(24 * 365 * np.multiply(farm_power_bl, freq_grid)) # Alternatively to above code, we could calculate AEP using - # 'fi_aep_parallel.get_farm_AEP(...)' but then we would not have the + # 'fmodel_aep_parallel.get_farm_AEP(...)' but then we would not have the # farm power productions, which we use later on for plotting. # First, get baseline AEP, without wake steering @@ -97,7 +97,7 @@ def load_windrose(): print(" ") # Load a FLORIS object for yaw optimization - fi_opt = load_floris() + fmodel_opt = load_floris() # Define arrays of wd/ws wind_directions_to_expand = np.arange(0.0, 360.0, 3.0) @@ -114,15 +114,15 @@ def load_windrose(): ws_array_opt = wind_speeds_grid.flatten() turbulence_intensities = 0.08 * np.ones_like(wd_array_opt) - fi_opt.set( + fmodel_opt.set( wind_directions=wd_array_opt, wind_speeds=ws_array_opt, turbulence_intensities=turbulence_intensities, ) # Pour this into a parallel computing interface - fi_opt_parallel = ParallelComputingInterface( - fi=fi_opt, + fmodel_opt_parallel = ParallelComputingInterface( + fmodel=fmodel_opt, max_workers=max_workers, n_wind_condition_splits=max_workers, interface=parallel_interface, @@ -130,7 +130,7 @@ def load_windrose(): ) # Now optimize the yaw angles using the Serial Refine method - df_opt = fi_opt_parallel.optimize_yaw_angles( + df_opt = fmodel_opt_parallel.optimize_yaw_angles( minimum_yaw_angle=-25.0, maximum_yaw_angle=25.0, Ny_passes=[5, 4], @@ -163,12 +163,12 @@ def load_windrose(): # Get optimized AEP, with wake steering yaw_grid = yaw_angles_interpolant(wd_array, ws_array) - farm_power_opt = fi_aep_parallel.get_farm_power(yaw_angles=yaw_grid) + farm_power_opt = fmodel_aep_parallel.get_farm_power(yaw_angles=yaw_grid) aep_opt = np.sum(24 * 365 * np.multiply(farm_power_opt, freq_grid)) aep_uplift = 100.0 * (aep_opt / aep_bl - 1) # Alternatively to above code, we could calculate AEP using - # 'fi_aep_parallel.get_farm_AEP(...)' but then we would not have the + # 'fmodel_aep_parallel.get_farm_AEP(...)' but then we would not have the # farm power productions, which we use later on for plotting. print(" ") @@ -196,7 +196,7 @@ def load_windrose(): }) # Plot power and AEP uplift across wind direction - wd_step = np.diff(fi_aep.floris.flow_field.wind_directions)[0] # Useful variable for plotting + wd_step = np.diff(fmodel_aep.core.flow_field.wind_directions)[0] # Useful variable for plotting fig, ax = plt.subplots(nrows=3, sharex=True) df_8ms = df[df["ws"] == 8.0].reset_index(drop=True) @@ -276,7 +276,7 @@ def load_windrose(): # Now plot yaw angle distributions over wind direction up to first three turbines wd_plot = np.arange(0.0, 360.001, 1.0) - for ti in range(np.min([fi_aep.floris.farm.n_turbines, 3])): + for ti in range(np.min([fmodel_aep.core.farm.n_turbines, 3])): fig, ax = plt.subplots(figsize=(6, 3.5)) ws_to_plot = [6.0, 9.0, 12.0] colors = ["maroon", "dodgerblue", "grey"] diff --git a/examples/13_optimize_yaw_with_neighboring_farm.py b/examples/13_optimize_yaw_with_neighboring_farm.py index bab42aaf3..18d5e1b26 100644 --- a/examples/13_optimize_yaw_with_neighboring_farm.py +++ b/examples/13_optimize_yaw_with_neighboring_farm.py @@ -4,8 +4,8 @@ import pandas as pd from scipy.interpolate import NearestNDInterpolator -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR """ @@ -25,8 +25,8 @@ def load_floris(): # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model + fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 + # fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Specify the full wind farm layout: nominal and neighboring wind farms X = np.array( @@ -51,7 +51,7 @@ def load_floris(): turbine_weights[0:10] = 1.0 # Now reinitialize FLORIS layout - fi.set(layout_x = X, layout_y = Y) + fmodel.set(layout_x = X, layout_y = Y) # And visualize the floris layout fig, ax = plt.subplots() @@ -62,7 +62,7 @@ def load_floris(): ax.set_ylabel("y coordinate (m)") ax.legend() - return fi, turbine_weights + return fmodel, turbine_weights def load_windrose(): @@ -89,32 +89,32 @@ def load_windrose(): return ws_windrose, wd_windrose, freq_windrose -def optimize_yaw_angles(fi_opt): +def optimize_yaw_angles(fmodel_opt): # Specify turbines to optimize - turbs_to_opt = np.zeros(len(fi_opt.layout_x), dtype=bool) + turbs_to_opt = np.zeros(len(fmodel_opt.layout_x), dtype=bool) turbs_to_opt[0:10] = True # Specify turbine weights - turbine_weights = np.zeros(len(fi_opt.layout_x)) + turbine_weights = np.zeros(len(fmodel_opt.layout_x)) turbine_weights[turbs_to_opt] = 1.0 # Specify minimum and maximum allowable yaw angle limits minimum_yaw_angle = np.zeros( ( - fi_opt.floris.flow_field.n_findex, - fi_opt.floris.farm.n_turbines, + fmodel_opt.core.flow_field.n_findex, + fmodel_opt.core.farm.n_turbines, ) ) maximum_yaw_angle = np.zeros( ( - fi_opt.floris.flow_field.n_findex, - fi_opt.floris.farm.n_turbines, + fmodel_opt.core.flow_field.n_findex, + fmodel_opt.core.farm.n_turbines, ) ) maximum_yaw_angle[:, turbs_to_opt] = 30.0 yaw_opt = YawOptimizationSR( - fi=fi_opt, + fmodel=fmodel_opt, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, turbine_weights=turbine_weights, @@ -136,8 +136,8 @@ def yaw_opt_interpolant(wd, ws): ws = np.array(ws, dtype=float) # Interpolate optimal yaw angles - x = yaw_opt.fi.floris.flow_field.wind_directions - nturbs = fi_opt.floris.farm.n_turbines + x = yaw_opt.fmodel.core.flow_field.wind_directions + nturbs = fmodel_opt.core.farm.n_turbines y = np.stack( [np.interp(wd, x, yaw_angles_opt[:, ti]) for ti in range(nturbs)], axis=np.ndim(wd) @@ -171,8 +171,8 @@ def yaw_opt_interpolant(wd, ws): if __name__ == "__main__": # Load FLORIS: full farm including neighboring wind farms - fi, turbine_weights = load_floris() - nturbs = len(fi.layout_x) + fmodel, turbine_weights = load_floris() + nturbs = len(fmodel.layout_x) # Load a dataframe containing the wind rose information ws_windrose, wd_windrose, freq_windrose = load_windrose() @@ -180,19 +180,19 @@ def yaw_opt_interpolant(wd, ws): turbulence_intensities_windrose = 0.06 * np.ones_like(wd_windrose) # Create a FLORIS object for AEP calculations - fi_AEP = fi.copy() - fi_AEP.set( + fmodel_aep = fmodel.copy() + fmodel_aep.set( wind_speeds=ws_windrose, wind_directions=wd_windrose, turbulence_intensities=turbulence_intensities_windrose ) # And create a separate FLORIS object for optimization - fi_opt = fi.copy() + fmodel_opt = fmodel.copy() wd_array = np.arange(0.0, 360.0, 3.0) ws_array = 8.0 * np.ones_like(wd_array) turbulence_intensities = 0.06 * np.ones_like(wd_array) - fi_opt.set( + fmodel_opt.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities, @@ -202,7 +202,7 @@ def yaw_opt_interpolant(wd, ws): print(" ") print("===========================================================") print("Calculating baseline annual energy production (AEP)...") - aep_bl_subset = 1.0e-9 * fi_AEP.get_farm_AEP( + aep_bl_subset = 1.0e-9 * fmodel_aep.get_farm_AEP( freq=freq_windrose, turbine_weights=turbine_weights ) @@ -225,19 +225,19 @@ def yaw_opt_interpolant(wd, ws): turbs_to_opt = (turbine_weights > 0.0001) # Optimize yaw angles while including neighboring farm - yaw_opt_interpolant = optimize_yaw_angles(fi_opt=fi_opt) + yaw_opt_interpolant = optimize_yaw_angles(fmodel_opt=fmodel_opt) # Optimize yaw angles while ignoring neighboring farm - fi_opt_subset = fi_opt.copy() - fi_opt_subset.set( - layout_x = fi.layout_x[turbs_to_opt], - layout_y = fi.layout_y[turbs_to_opt] + fmodel_opt_subset = fmodel_opt.copy() + fmodel_opt_subset.set( + layout_x = fmodel.layout_x[turbs_to_opt], + layout_y = fmodel.layout_y[turbs_to_opt] ) - yaw_opt_interpolant_nonb = optimize_yaw_angles(fi_opt=fi_opt_subset) + yaw_opt_interpolant_nonb = optimize_yaw_angles(fmodel_opt=fmodel_opt_subset) - # Use interpolant to get optimal yaw angles for fi_AEP object - wd = fi_AEP.floris.flow_field.wind_directions - ws = fi_AEP.floris.flow_field.wind_speeds + # Use interpolant to get optimal yaw angles for fmodel_aep object + wd = fmodel_aep.core.flow_field.wind_directions + ws = fmodel_aep.core.flow_field.wind_speeds yaw_angles_opt_AEP = yaw_opt_interpolant(wd, ws) yaw_angles_opt_nonb_AEP = np.zeros_like(yaw_angles_opt_AEP) # nonb = no neighbor yaw_angles_opt_nonb_AEP[:, turbs_to_opt] = yaw_opt_interpolant_nonb(wd, ws) @@ -246,13 +246,13 @@ def yaw_opt_interpolant(wd, ws): print(" ") print("===========================================================") print("Calculating annual energy production with wake steering (AEP)...") - fi_AEP.set(yaw_angles=yaw_angles_opt_nonb_AEP) - aep_opt_subset_nonb = 1.0e-9 * fi_AEP.get_farm_AEP( + fmodel_aep.set(yaw_angles=yaw_angles_opt_nonb_AEP) + aep_opt_subset_nonb = 1.0e-9 * fmodel_aep.get_farm_AEP( freq=freq_windrose, turbine_weights=turbine_weights, ) - fi_AEP.set(yaw_angles=yaw_angles_opt_AEP) - aep_opt_subset = 1.0e-9 * fi_AEP.get_farm_AEP( + fmodel_aep.set(yaw_angles=yaw_angles_opt_AEP) + aep_opt_subset = 1.0e-9 * fmodel_aep.get_farm_AEP( freq=freq_windrose, turbine_weights=turbine_weights, ) @@ -270,38 +270,38 @@ def yaw_opt_interpolant(wd, ws): print(" ") # Plot power and AEP uplift across wind direction at wind_speed of 8 m/s - wd = fi_opt.floris.flow_field.wind_directions - ws = fi_opt.floris.flow_field.wind_speeds + wd = fmodel_opt.core.flow_field.wind_directions + ws = fmodel_opt.core.flow_field.wind_speeds yaw_angles_opt = yaw_opt_interpolant(wd, ws) yaw_angles_opt_nonb = np.zeros_like(yaw_angles_opt) # nonb = no neighbor yaw_angles_opt_nonb[:, turbs_to_opt] = yaw_opt_interpolant_nonb(wd, ws) - fi_opt = fi_opt.copy() - fi_opt.set(yaw_angles=np.zeros_like(yaw_angles_opt)) - fi_opt.run() - farm_power_bl_subset = fi_opt.get_farm_power(turbine_weights).flatten() + fmodel_opt = fmodel_opt.copy() + fmodel_opt.set(yaw_angles=np.zeros_like(yaw_angles_opt)) + fmodel_opt.run() + farm_power_bl_subset = fmodel_opt.get_farm_power(turbine_weights).flatten() - fi_opt = fi_opt.copy() - fi_opt.set(yaw_angles=yaw_angles_opt) - fi_opt.run() - farm_power_opt_subset = fi_opt.get_farm_power(turbine_weights).flatten() + fmodel_opt = fmodel_opt.copy() + fmodel_opt.set(yaw_angles=yaw_angles_opt) + fmodel_opt.run() + farm_power_opt_subset = fmodel_opt.get_farm_power(turbine_weights).flatten() - fi_opt = fi_opt.copy() - fi_opt.set(yaw_angles=yaw_angles_opt_nonb) - fi_opt.run() - farm_power_opt_subset_nonb = fi_opt.get_farm_power(turbine_weights).flatten() + fmodel_opt = fmodel_opt.copy() + fmodel_opt.set(yaw_angles=yaw_angles_opt_nonb) + fmodel_opt.run() + farm_power_opt_subset_nonb = fmodel_opt.get_farm_power(turbine_weights).flatten() fig, ax = plt.subplots() ax.bar( - x=fi_opt.floris.flow_field.wind_directions - 0.65, + x=fmodel_opt.core.flow_field.wind_directions - 0.65, height=100.0 * (farm_power_opt_subset / farm_power_bl_subset - 1.0), edgecolor="black", width=1.3, label="Including wake effects of neighboring farms" ) ax.bar( - x=fi_opt.floris.flow_field.wind_directions + 0.65, + x=fmodel_opt.core.flow_field.wind_directions + 0.65, height=100.0 * (farm_power_opt_subset_nonb / farm_power_bl_subset - 1.0), edgecolor="black", width=1.3, diff --git a/examples/14_compare_yaw_optimizers.py b/examples/14_compare_yaw_optimizers.py index ea4e100ee..4e0fa1d99 100644 --- a/examples/14_compare_yaw_optimizers.py +++ b/examples/14_compare_yaw_optimizers.py @@ -4,18 +4,18 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric import ( +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( YawOptimizationGeometric, ) -from floris.tools.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR """ This example compares the SciPy-based yaw optimizer with the new Serial-Refine optimizer. -First, we initialize our Floris Interface, and then generate a 3 turbine wind farm. +First, we initialize Floris, and then generate a 3 turbine wind farm. Next, we create two yaw optimization objects, `yaw_opt_sr` and `yaw_opt_scipy` for the Serial-Refine and SciPy methods, respectively. We then perform the optimization using both methods. @@ -25,21 +25,21 @@ The example now also compares the Geometric Yaw optimizer, which is fast a method to find approximately optimal yaw angles based on the wind farm geometry. Its main use case is for coupled layout and yaw optimization. -see floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric.py and the paper online +see floris.optimization.yaw_optimization.yaw_optimizer_geometric.py and the paper online at https://wes.copernicus.org/preprints/wes-2023-1/. See also example 16c. """ # Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +# fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model # Reinitialize as a 3-turbine farm with range of WDs and 1 WS D = 126.0 # Rotor diameter for the NREL 5 MW wd_array = np.arange(0.0, 360.0, 3.0) ws_array = 8.0 * np.ones_like(wd_array) turbulence_intensities = 0.06 * np.ones_like(wd_array) -fi.set( +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, @@ -49,19 +49,19 @@ print("Performing optimizations with SciPy...") start_time = timerpc() -yaw_opt_scipy = YawOptimizationScipy(fi) +yaw_opt_scipy = YawOptimizationScipy(fmodel) df_opt_scipy = yaw_opt_scipy.optimize() time_scipy = timerpc() - start_time print("Performing optimizations with Serial Refine...") start_time = timerpc() -yaw_opt_sr = YawOptimizationSR(fi) +yaw_opt_sr = YawOptimizationSR(fmodel) df_opt_sr = yaw_opt_sr.optimize() time_sr = timerpc() - start_time print("Performing optimizations with Geometric Yaw...") start_time = timerpc() -yaw_opt_geo = YawOptimizationGeometric(fi) +yaw_opt_geo = YawOptimizationGeometric(fmodel) df_opt_geo = yaw_opt_geo.optimize() time_geo = timerpc() - start_time @@ -94,9 +94,9 @@ # Before plotting results, need to compute values for GEOOPT since it doesn't compute # power within the optimization -fi.set(yaw_angles=yaw_angles_opt_geo) -fi.run() -geo_farm_power = fi.get_farm_power().squeeze() +fmodel.set(yaw_angles=yaw_angles_opt_geo) +fmodel.run() +geo_farm_power = fmodel.get_farm_power().squeeze() fig, ax = plt.subplots() diff --git a/examples/15_optimize_layout.py b/examples/15_optimize_layout.py index 8049b0e6c..071a62b87 100644 --- a/examples/15_optimize_layout.py +++ b/examples/15_optimize_layout.py @@ -4,8 +4,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface, WindRose -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_scipy import ( LayoutOptimizationScipy, ) @@ -22,7 +22,7 @@ # Initialize the FLORIS interface fi file_dir = os.path.dirname(os.path.abspath(__file__)) -fi = FlorisInterface('inputs/gch.yaml') +fmodel = FlorisModel('inputs/gch.yaml') # Setup 72 wind directions with a 1 wind speed and frequency distribution wind_directions = np.arange(0, 360.0, 5.0) @@ -42,7 +42,7 @@ ti_table=0.06 ) -fi.set(wind_data=wind_rose) +fmodel.set(wind_data=wind_rose) # The boundaries for the turbines, specified as vertices boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] @@ -51,21 +51,21 @@ D = 126.0 # rotor diameter for the NREL 5MW layout_x = [0, 0, 6 * D, 6 * D] layout_y = [0, 4 * D, 0, 4 * D] -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) # Setup the optimization problem -layout_opt = LayoutOptimizationScipy(fi, boundaries, wind_data=wind_rose) +layout_opt = LayoutOptimizationScipy(fmodel, boundaries, wind_data=wind_rose) # Run the optimization sol = layout_opt.optimize() # Get the resulting improvement in AEP print('... calcuating improvement in AEP') -fi.run() -base_aep = fi.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 -fi.set(layout_x=sol[0], layout_y=sol[1]) -fi.run() -opt_aep = fi.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 +fmodel.run() +base_aep = fmodel.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1]) +fmodel.run() +opt_aep = fmodel.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 percent_gain = 100 * (opt_aep - base_aep) / base_aep diff --git a/examples/16_heterogeneous_inflow.py b/examples/16_heterogeneous_inflow.py index 335a8043a..26451ffa5 100644 --- a/examples/16_heterogeneous_inflow.py +++ b/examples/16_heterogeneous_inflow.py @@ -1,8 +1,8 @@ import matplotlib.pyplot as plt -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane """ @@ -22,7 +22,7 @@ """ -# Initialize FLORIS with the given input file via FlorisInterface. +# Initialize FLORIS with the given input file via FlorisModel. # Note that the heterogeneous flow is defined in the input file. The heterogenous_inflow_config # dictionary is defined as below. The speed ups are multipliers of the ambient wind speed, # and the x and y are the locations of the speed ups. @@ -34,20 +34,20 @@ # } -fi_2d = FlorisInterface("inputs/gch_heterogeneous_inflow.yaml") +fmodel_2d = FlorisModel("inputs/gch_heterogeneous_inflow.yaml") # Set shear to 0.0 to highlight the heterogeneous inflow -fi_2d.set(wind_shear=0.0) +fmodel_2d.set(wind_shear=0.0) -# Using the FlorisInterface functions for generating plots, run FLORIS +# Using the FlorisModel functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_2d = fi_2d.calculate_horizontal_plane( +horizontal_plane_2d = fmodel_2d.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=90.0 ) -y_plane_2d = fi_2d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) -cross_plane_2d = fi_2d.calculate_cross_plane( +y_plane_2d = fmodel_2d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane_2d = fmodel_2d.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=500.0 @@ -101,28 +101,28 @@ 'z': z_locs, } -# Initialize FLORIS with the given input file via FlorisInterface. +# Initialize FLORIS with the given input file. # Note that we initialize FLORIS with a homogenous flow input file, but # then configure the heterogeneous inflow via the reinitialize method. -fi_3d = FlorisInterface("inputs/gch.yaml") -fi_3d.set(heterogenous_inflow_config=heterogenous_inflow_config) +fmodel_3d = FlorisModel("inputs/gch.yaml") +fmodel_3d.set(heterogenous_inflow_config=heterogenous_inflow_config) # Set shear to 0.0 to highlight the heterogeneous inflow -fi_3d.set(wind_shear=0.0) +fmodel_3d.set(wind_shear=0.0) -# Using the FlorisInterface functions for generating plots, run FLORIS +# Using the FlorisModel functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane_3d = fi_3d.calculate_horizontal_plane( +horizontal_plane_3d = fmodel_3d.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=90.0 ) -y_plane_3d = fi_3d.calculate_y_plane( +y_plane_3d = fmodel_3d.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=0.0 ) -cross_plane_3d = fi_3d.calculate_cross_plane( +cross_plane_3d = fmodel_3d.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=500.0 diff --git a/examples/16b_heterogeneity_multiple_ws_wd.py b/examples/16b_heterogeneity_multiple_ws_wd.py index 56dbd3e9b..c183c4a26 100644 --- a/examples/16b_heterogeneity_multiple_ws_wd.py +++ b/examples/16b_heterogeneity_multiple_ws_wd.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane """ @@ -19,12 +19,12 @@ x_locs = [-300.0, -300.0, 2600.0, 2600.0] y_locs = [ -300.0, 300.0, -300.0, 300.0] -# Initialize FLORIS with the given input file via FlorisInterface. +# Initialize FLORIS with the given input. # Note the heterogeneous inflow is defined in the input file. -fi = FlorisInterface("inputs/gch_heterogeneous_inflow.yaml") +fmodel = FlorisModel("inputs/gch_heterogeneous_inflow.yaml") # Set shear to 0.0 to highlight the heterogeneous inflow -fi.set( +fmodel.set( wind_shear=0.0, wind_speeds=[8.0], wind_directions=[270.], @@ -32,8 +32,8 @@ layout_x=[0, 0], layout_y=[-299., 299.], ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten() / 1000. +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten() / 1000. # Show the initial results print('------------------------------------------') @@ -53,14 +53,14 @@ 'x': x_locs, 'y': y_locs, } -fi.set( +fmodel.set( wind_directions=[270.0, 275.0], wind_speeds=[8.0, 8.0], turbulence_intensities=[0.06, 0.06], heterogenous_inflow_config=heterogenous_inflow_config ) -fi.run() -turbine_powers = np.round(fi.get_turbine_powers() / 1000.) +fmodel.run() +turbine_powers = np.round(fmodel.get_turbine_powers() / 1000.) print('With wind directions now set to 270 and 275 deg') print(f'T0: {turbine_powers[:, 0].flatten()} kW') print(f'T1: {turbine_powers[:, 1].flatten()} kW') @@ -71,6 +71,6 @@ # print() # print('~~ Now forcing an error by not matching wd and het_map') -# fi.set(wind_directions=[270, 275, 280], wind_speeds=3*[8.0]) -# fi.run() -# turbine_powers = np.round(fi.get_turbine_powers() / 1000.) +# fmodel.set(wind_directions=[270, 275, 280], wind_speeds=3*[8.0]) +# fmodel.run() +# turbine_powers = np.round(fmodel.get_turbine_powers() / 1000.) diff --git a/examples/16c_optimize_layout_with_heterogeneity.py b/examples/16c_optimize_layout_with_heterogeneity.py index d41ac70a0..616b60e68 100644 --- a/examples/16c_optimize_layout_with_heterogeneity.py +++ b/examples/16c_optimize_layout_with_heterogeneity.py @@ -4,8 +4,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface, WindRose -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_scipy import ( LayoutOptimizationScipy, ) @@ -22,9 +22,9 @@ show the benefits of coupled optimization when flows are heterogeneous. """ -# Initialize the FLORIS interface fi +# Initialize FLORIS file_dir = os.path.dirname(os.path.abspath(__file__)) -fi = FlorisInterface('inputs/gch.yaml') +fmodel = FlorisModel('inputs/gch.yaml') # Setup 2 wind directions (due east and due west) # and 1 wind speed with uniform probability @@ -76,7 +76,7 @@ ) -fi.set( +fmodel.set( layout_x=layout_x, layout_y=layout_y, wind_data=wind_rose, @@ -85,7 +85,7 @@ # Setup and solve the layout optimization problem without heterogeneity maxiter = 100 layout_opt = LayoutOptimizationScipy( - fi, + fmodel, boundaries, wind_data=wind_rose, min_dist=2*D, @@ -99,11 +99,11 @@ # Get the resulting improvement in AEP print('... calcuating improvement in AEP') -fi.run() -base_aep = fi.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 -fi.set(layout_x=sol[0], layout_y=sol[1]) -fi.run() -opt_aep = fi.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 +fmodel.run() +base_aep = fmodel.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1]) +fmodel.run() +opt_aep = fmodel.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 percent_gain = 100 * (opt_aep - base_aep) / base_aep @@ -124,9 +124,9 @@ # Rerun the layout optimization with geometric yaw enabled print("\nReoptimizing with geometric yaw enabled.") -fi.set(layout_x=layout_x, layout_y=layout_y) +fmodel.set(layout_x=layout_x, layout_y=layout_y) layout_opt = LayoutOptimizationScipy( - fi, + fmodel, boundaries, wind_data=wind_rose, min_dist=2*D, @@ -141,11 +141,11 @@ # Get the resulting improvement in AEP print('... calcuating improvement in AEP') -fi.set(yaw_angles=np.zeros_like(layout_opt.yaw_angles)) -base_aep = fi.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 -fi.set(layout_x=sol[0], layout_y=sol[1], yaw_angles=layout_opt.yaw_angles) -fi.run() -opt_aep = fi.get_farm_AEP_with_wind_data( +fmodel.set(yaw_angles=np.zeros_like(layout_opt.yaw_angles)) +base_aep = fmodel.get_farm_AEP_with_wind_data(wind_data=wind_rose) / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1], yaw_angles=layout_opt.yaw_angles) +fmodel.run() +opt_aep = fmodel.get_farm_AEP_with_wind_data( wind_data=wind_rose ) / 1e6 diff --git a/examples/17_multiple_turbine_types.py b/examples/17_multiple_turbine_types.py index cd913b832..b7d1c4173 100644 --- a/examples/17_multiple_turbine_types.py +++ b/examples/17_multiple_turbine_types.py @@ -1,8 +1,8 @@ import matplotlib.pyplot as plt -import floris.tools.flow_visualization as flowviz -from floris.tools import FlorisInterface +import floris.flow_visualization as flowviz +from floris import FlorisModel """ @@ -10,16 +10,20 @@ The first two turbines are the NREL 5MW, and the third turbine is the IEA 10MW. """ -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive +# Initialize FLORIS with the given input file. +# For basic usage, FlorisModel provides a simplified and expressive # entry point to the simulation routines. -fi = FlorisInterface("inputs/gch_multiple_turbine_types.yaml") +fmodel = FlorisModel("inputs/gch_multiple_turbine_types.yaml") -# Using the FlorisInterface functions for generating plots, run FLORIS +# Using the FlorisModel functions for generating plots, run FLORIS # and extract 2D planes of data. -horizontal_plane = fi.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90) -y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) -cross_plane = fi.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) +horizontal_plane = fmodel.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90) +y_plane = fmodel.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane = fmodel.calculate_cross_plane( + y_resolution=100, + z_resolution=100, + downstream_dist=500.0 +) # Create the plots fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) diff --git a/examples/18_check_turbine.py b/examples/18_check_turbine.py index da526e7da..258525340 100644 --- a/examples/18_check_turbine.py +++ b/examples/18_check_turbine.py @@ -4,7 +4,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -18,13 +18,13 @@ wind_speed_to_test_yaw = 11 # Grab the gch model -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") # Make one turbine simulation -fi.set(layout_x=[0], layout_y=[0]) +fmodel.set(layout_x=[0], layout_y=[0]) # Apply wind directions and wind speeds -fi.set( +fmodel.set( wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=turbulence_intensities @@ -34,7 +34,7 @@ # multi-dimensional Cp/Ct turbine definitions as they require different handling turbines = [ t.stem - for t in fi.floris.farm.internal_turbine_library.iterdir() + for t in fmodel.core.farm.internal_turbine_library.iterdir() if t.suffix == ".yaml" and ("multi_dim" not in t.stem) ] @@ -45,22 +45,22 @@ for t in turbines: # Set t as the turbine - fi.set(turbine_type=[t]) + fmodel.set(turbine_type=[t]) # Since we are changing the turbine type, make a matching change to the reference wind height - fi.assign_hub_height_to_ref_height() + fmodel.assign_hub_height_to_ref_height() # Plot power and ct onto the fig_pow_ct plot axarr_pow_ct[0].plot( - fi.floris.farm.turbine_map[0].power_thrust_table["wind_speed"], - fi.floris.farm.turbine_map[0].power_thrust_table["power"],label=t + fmodel.core.farm.turbine_map[0].power_thrust_table["wind_speed"], + fmodel.core.farm.turbine_map[0].power_thrust_table["power"],label=t ) axarr_pow_ct[0].grid(True) axarr_pow_ct[0].legend() axarr_pow_ct[0].set_ylabel('Power (kW)') axarr_pow_ct[1].plot( - fi.floris.farm.turbine_map[0].power_thrust_table["wind_speed"], - fi.floris.farm.turbine_map[0].power_thrust_table["thrust_coefficient"],label=t + fmodel.core.farm.turbine_map[0].power_thrust_table["wind_speed"], + fmodel.core.farm.turbine_map[0].power_thrust_table["thrust_coefficient"],label=t ) axarr_pow_ct[1].grid(True) axarr_pow_ct[1].legend() @@ -73,17 +73,17 @@ # Try a few density for density in [1.15,1.225,1.3]: - fi.set(air_density=density) + fmodel.set(air_density=density) # POWER CURVE ax = axarr[0] - fi.set( + fmodel.set( wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=turbulence_intensities ) - fi.run() - turbine_powers = fi.get_turbine_powers().flatten() / 1e3 + fmodel.run() + turbine_powers = fmodel.get_turbine_powers().flatten() / 1e3 if density == 1.225: ax.plot(ws_array,turbine_powers,label='Air Density = %.3f' % density, lw=2, color='k') else: @@ -96,16 +96,16 @@ # Power loss to yaw, try a range of yaw angles ax = axarr[1] - fi.set( + fmodel.set( wind_speeds=[wind_speed_to_test_yaw], wind_directions=[270.0], turbulence_intensities=[0.06] ) yaw_result = [] for yaw in yaw_angles: - fi.set(yaw_angles=np.array([[yaw]])) - fi.run() - turbine_powers = fi.get_turbine_powers().flatten() / 1e3 + fmodel.set(yaw_angles=np.array([[yaw]])) + fmodel.run() + turbine_powers = fmodel.get_turbine_powers().flatten() / 1e3 yaw_result.append(turbine_powers[0]) if density == 1.225: ax.plot(yaw_angles,yaw_result,label='Air Density = %.3f' % density, lw=2, color='k') diff --git a/examples/20_calculate_farm_power_with_uncertainty.py b/examples/20_calculate_farm_power_with_uncertainty.py index 21aa18286..96a1818d0 100644 --- a/examples/20_calculate_farm_power_with_uncertainty.py +++ b/examples/20_calculate_farm_power_with_uncertainty.py @@ -1,25 +1,25 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface, UncertaintyInterface +from floris import FlorisModel, UncertaintyInterface """ This example demonstrates how one can create an "UncertaintyInterface" object, -which adds uncertainty on the inflow wind direction on the FlorisInterface +which adds uncertainty on the inflow wind direction on the FlorisModel class. The UncertaintyInterface class is interacted with in the exact same -manner as the FlorisInterface class is. This example demonstrates how the +manner as the FlorisModel class is. This example demonstrates how the wind farm power production is calculated with and without uncertainty. Other use cases of UncertaintyInterface are, e.g., comparing FLORIS to historical SCADA data and robust optimization. """ # Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model -fi_unc_3 = UncertaintyInterface( +fmodel = FlorisModel("inputs/gch.yaml") # GCH model +umodel_unc_3 = UncertaintyInterface( "inputs/gch.yaml", verbose=True, wd_std=3 ) -fi_unc_5 = UncertaintyInterface( +umodel_unc_5 = UncertaintyInterface( "inputs/gch.yaml", verbose=True, wd_std=5 ) @@ -29,27 +29,27 @@ layout_y = [0, 0] wd_array = np.arange(240.0, 300.0, 1.0) wind_speeds = 8.0 * np.ones_like(wd_array) -fi.set(layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array, wind_speeds=wind_speeds) -fi_unc_3.set( +fmodel.set(layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array, wind_speeds=wind_speeds) +umodel_unc_3.set( layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array, wind_speeds=wind_speeds ) -fi_unc_5.set( +umodel_unc_5.set( layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array, wind_speeds=wind_speeds ) # Run both models -fi.run() -fi_unc_3.run() -fi_unc_5.run() +fmodel.run() +umodel_unc_3.run() +umodel_unc_5.run() # Collect the nominal and uncertain farm power -turbine_powers_nom = fi.get_turbine_powers() / 1e3 -turbine_powers_unc_3 = fi_unc_3.get_turbine_powers() / 1e3 -turbine_powers_unc_5 = fi_unc_5.get_turbine_powers() / 1e3 -farm_powers_nom = fi.get_farm_power() / 1e3 -farm_powers_unc_3 = fi_unc_3.get_farm_power() / 1e3 -farm_powers_unc_5 = fi_unc_5.get_farm_power() / 1e3 +turbine_powers_nom = fmodel.get_turbine_powers() / 1e3 +turbine_powers_unc_3 = umodel_unc_3.get_turbine_powers() / 1e3 +turbine_powers_unc_5 = umodel_unc_5.get_turbine_powers() / 1e3 +farm_powers_nom = fmodel.get_farm_power() / 1e3 +farm_powers_unc_3 = umodel_unc_3.get_farm_power() / 1e3 +farm_powers_unc_5 = umodel_unc_5.get_farm_power() / 1e3 # Plot results fig, axarr = plt.subplots(1, 3, figsize=(15, 5)) @@ -108,9 +108,9 @@ freq = np.ones_like(wd_array) freq = freq / freq.sum() -aep_nom = fi.get_farm_AEP(freq=freq) -aep_unc_3 = fi_unc_3.get_farm_AEP(freq=freq) -aep_unc_5 = fi_unc_5.get_farm_AEP(freq=freq) +aep_nom = fmodel.get_farm_AEP(freq=freq) +aep_unc_3 = umodel_unc_3.get_farm_AEP(freq=freq) +aep_unc_5 = umodel_unc_5.get_farm_AEP(freq=freq) print(f"AEP without uncertainty {aep_nom}") print(f"AEP without uncertainty (3 deg) {aep_unc_3} ({100*aep_unc_3/aep_nom:.2f}%)") diff --git a/examples/21_demo_time_series.py b/examples/21_demo_time_series.py index 61f9b7995..8afa28f2f 100644 --- a/examples/21_demo_time_series.py +++ b/examples/21_demo_time_series.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -11,10 +11,10 @@ """ # Initialize FLORIS to simple 4 turbine farm -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") # Convert to a simple two turbine layout -fi.set(layout_x=[0, 500.], layout_y=[0., 0.]) +fmodel.set(layout_x=[0, 500.], layout_y=[0., 0.]) # Create a fake time history where wind speed steps in the middle while wind direction # Walks randomly @@ -29,14 +29,14 @@ # Now intiialize FLORIS object to this history using time_series flag -fi.set(wind_directions=wd, wind_speeds=ws, turbulence_intensities=turbulence_intensities) +fmodel.set(wind_directions=wd, wind_speeds=ws, turbulence_intensities=turbulence_intensities) # Collect the powers -fi.run() -turbine_powers = fi.get_turbine_powers() / 1000. +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1000. # Show the dimensions -num_turbines = len(fi.layout_x) +num_turbines = len(fmodel.layout_x) print( f'There are {len(time)} time samples, and {num_turbines} turbines and ' f'so the resulting turbine power matrix has the shape {turbine_powers.shape}.' diff --git a/examples/22_get_wind_speed_at_turbines.py b/examples/22_get_wind_speed_at_turbines.py index b5dfeb7d4..7f15a4100 100644 --- a/examples/22_get_wind_speed_at_turbines.py +++ b/examples/22_get_wind_speed_at_turbines.py @@ -1,33 +1,33 @@ import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive +# Initialize FLORIS with the given input file. +# For basic usage, FlorisModel provides a simplified and expressive # entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") # Create a 4-turbine layouts -fi.set(layout_x=[0, 0., 500., 500.], layout_y=[0., 300., 0., 300.]) +fmodel.set(layout_x=[0, 0., 500., 500.], layout_y=[0., 300., 0., 300.]) # Calculate wake -fi.run() +fmodel.run() # Collect the wind speed at all the turbine points -u_points = fi.floris.flow_field.u +u_points = fmodel.core.flow_field.u print('U points is 1 findex x 4 turbines x 3 x 3 points (turbine_grid_points=3)') print(u_points.shape) print('turbine_average_velocities is 1 findex x 4 turbines') -print(fi.turbine_average_velocities) +print(fmodel.turbine_average_velocities) # Show that one is equivalent to the other following averaging print( 'turbine_average_velocities is determined by taking the cube root of mean ' 'of the cubed value across the points ' ) -print(f'turbine_average_velocities: {fi.turbine_average_velocities}') +print(f'turbine_average_velocities: {fmodel.turbine_average_velocities}') print(f'Recomputed: {np.cbrt(np.mean(u_points**3, axis=(2,3)))}') diff --git a/examples/23_layout_visualizations.py b/examples/23_layout_visualizations.py index 1b84f602a..465490e6e 100644 --- a/examples/23_layout_visualizations.py +++ b/examples/23_layout_visualizations.py @@ -2,9 +2,9 @@ import matplotlib.pyplot as plt import numpy as np -import floris.tools.layout_visualization as layoutviz -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import visualize_cut_plane +import floris.layout_visualization as layoutviz +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane """ @@ -18,18 +18,18 @@ MIN_WS = 1.0 MAX_WS = 8.0 -# Initialize FLORIS with the given input file via FlorisInterface -fi = FlorisInterface("inputs/gch.yaml") +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("inputs/gch.yaml") # Change to 5-turbine layout with a wind direction from northwest -fi.set( +fmodel.set( layout_x=[0, 0, 1000, 1000, 1000], layout_y=[0, 500, 0, 500, 1000], wind_directions=[300] ) # Plot 1: Visualize the flow ax = axarr[0] # Plot a horizatonal slice of the initial configuration -horizontal_plane = fi.calculate_horizontal_plane(height=90.0) +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0) visualize_cut_plane( horizontal_plane, ax=ax, @@ -37,14 +37,14 @@ max_speed=MAX_WS, ) # Plot the turbine points, setting the color to white -layoutviz.plot_turbine_points(fi, ax=ax, plotting_dict={"color": "w"}) +layoutviz.plot_turbine_points(fmodel, ax=ax, plotting_dict={"color": "w"}) ax.set_title('Flow visualization and turbine points') # Plot 2: Show a particular flow case ax = axarr[1] turbine_names = [f"T{i}" for i in [10, 11, 12, 13, 22]] -layoutviz.plot_turbine_points(fi, ax=ax) -layoutviz.plot_turbine_labels(fi, +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names, show_bbox=True, @@ -54,7 +54,7 @@ # Plot 2: Show turbine rotors on flow ax = axarr[2] -horizontal_plane = fi.calculate_horizontal_plane(height=90.0, +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0, yaw_angles=np.array([[0., 30., 0., 0., 0.]])) visualize_cut_plane( horizontal_plane, @@ -62,32 +62,32 @@ min_speed=MIN_WS, max_speed=MAX_WS ) -layoutviz.plot_turbine_rotors(fi,ax=ax,yaw_angles=np.array([[0., 30., 0., 0., 0.]])) +layoutviz.plot_turbine_rotors(fmodel,ax=ax,yaw_angles=np.array([[0., 30., 0., 0., 0.]])) ax.set_title("Flow visualization with yawed turbine") # Plot 3: Show the layout, including wake directions ax = axarr[3] -layoutviz.plot_turbine_points(fi, ax=ax) -layoutviz.plot_turbine_labels(fi, ax=ax, turbine_names=turbine_names) -layoutviz.plot_waking_directions(fi, ax=ax) +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names) +layoutviz.plot_waking_directions(fmodel, ax=ax) ax.set_title("Show turbine names and wake direction") # Plot 4: Plot a subset of the layout, and limit directions less than 7D ax = axarr[4] -layoutviz.plot_turbine_points(fi, ax=ax, turbine_indices=[0,1,2,3]) -layoutviz.plot_turbine_labels(fi, ax=ax, turbine_names=turbine_names, turbine_indices=[0,1,2,3]) -layoutviz.plot_waking_directions(fi, ax=ax, turbine_indices=[0,1,2,3], limit_dist_D=7) +layoutviz.plot_turbine_points(fmodel, ax=ax, turbine_indices=[0,1,2,3]) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names, turbine_indices=[0,1,2,3]) +layoutviz.plot_waking_directions(fmodel, ax=ax, turbine_indices=[0,1,2,3], limit_dist_D=7) ax.set_title("Plot a subset and limit wake line distance") # Plot with a shaded region ax = axarr[5] -layoutviz.plot_turbine_points(fi, ax=ax) +layoutviz.plot_turbine_points(fmodel, ax=ax) layoutviz.shade_region(np.array([[0,0],[300,0],[300,1000],[0,700]]),ax=ax) ax.set_title("Plot with a shaded region") # Change hub heights and plot as a proxy for terrain ax = axarr[6] -fi.floris.farm.hub_heights = np.array([110, 90, 100, 100, 95]) -layoutviz.plot_farm_terrain(fi, ax=ax) +fmodel.core.farm.hub_heights = np.array([110, 90, 100, 100, 95]) +layoutviz.plot_farm_terrain(fmodel, ax=ax) plt.show() diff --git a/examples/24_floating_turbine_models.py b/examples/24_floating_turbine_models.py index 63aecc4c0..76822a76f 100644 --- a/examples/24_floating_turbine_models.py +++ b/examples/24_floating_turbine_models.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -25,59 +25,61 @@ In the example below, three single-turbine simulations are run to show the different behaviors. -fi_fixed: Fixed bottom turbine (no tilt variation with wind speed) -fi_floating: Floating turbine (tilt varies with wind speed) -fi_floating_defined_floating: Floating turbine (tilt varies with wind speed, but +fmodel_fixed: Fixed bottom turbine (no tilt variation with wind speed) +fmodel_floating: Floating turbine (tilt varies with wind speed) +fmodel_floating_defined_floating: Floating turbine (tilt varies with wind speed, but tilt does not scale cp/ct) """ -# Declare the Floris Interfaces -fi_fixed = FlorisInterface("inputs_floating/gch_fixed.yaml") -fi_floating = FlorisInterface("inputs_floating/gch_floating.yaml") -fi_floating_defined_floating = FlorisInterface("inputs_floating/gch_floating_defined_floating.yaml") +# Create the Floris instances +fmodel_fixed = FlorisModel("inputs_floating/gch_fixed.yaml") +fmodel_floating = FlorisModel("inputs_floating/gch_floating.yaml") +fmodel_floating_defined_floating = FlorisModel("inputs_floating/gch_floating_defined_floating.yaml") # Calculate across wind speeds ws_array = np.arange(3., 25., 1.) wd_array = 270.0 * np.ones_like(ws_array) ti_array = 0.06 * np.ones_like(ws_array) -fi_fixed.set(wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=ti_array) -fi_floating.set(wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=ti_array) -fi_floating_defined_floating.set( +fmodel_fixed.set(wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=ti_array) +fmodel_floating.set(wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=ti_array) +fmodel_floating_defined_floating.set( wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=ti_array ) -fi_fixed.run() -fi_floating.run() -fi_floating_defined_floating.run() +fmodel_fixed.run() +fmodel_floating.run() +fmodel_floating_defined_floating.run() # Grab power -power_fixed = fi_fixed.get_turbine_powers().flatten()/1000. -power_floating = fi_floating.get_turbine_powers().flatten()/1000. -power_floating_defined_floating = fi_floating_defined_floating.get_turbine_powers().flatten()/1000. +power_fixed = fmodel_fixed.get_turbine_powers().flatten()/1000. +power_floating = fmodel_floating.get_turbine_powers().flatten()/1000. +power_floating_defined_floating = ( + fmodel_floating_defined_floating.get_turbine_powers().flatten()/1000. +) # Grab Ct -ct_fixed = fi_fixed.get_turbine_thrust_coefficients().flatten() -ct_floating = fi_floating.get_turbine_thrust_coefficients().flatten() +ct_fixed = fmodel_fixed.get_turbine_thrust_coefficients().flatten() +ct_floating = fmodel_floating.get_turbine_thrust_coefficients().flatten() ct_floating_defined_floating = ( - fi_floating_defined_floating.get_turbine_thrust_coefficients().flatten() + fmodel_floating_defined_floating.get_turbine_thrust_coefficients().flatten() ) # Grab turbine tilt angles -eff_vels = fi_fixed.turbine_average_velocities +eff_vels = fmodel_fixed.turbine_average_velocities tilt_angles_fixed = np.squeeze( - fi_fixed.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) + fmodel_fixed.core.farm.calculate_tilt_for_eff_velocities(eff_vels) ) -eff_vels = fi_floating.turbine_average_velocities +eff_vels = fmodel_floating.turbine_average_velocities tilt_angles_floating = np.squeeze( - fi_floating.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) + fmodel_floating.core.farm.calculate_tilt_for_eff_velocities(eff_vels) ) -eff_vels = fi_floating_defined_floating.turbine_average_velocities +eff_vels = fmodel_floating_defined_floating.turbine_average_velocities tilt_angles_floating_defined_floating = np.squeeze( - fi_floating_defined_floating.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) + fmodel_floating_defined_floating.core.farm.calculate_tilt_for_eff_velocities(eff_vels) ) # Plot results diff --git a/examples/25_tilt_driven_vertical_wake_deflection.py b/examples/25_tilt_driven_vertical_wake_deflection.py index 1efd5aa8a..b8d6ffbf5 100644 --- a/examples/25_tilt_driven_vertical_wake_deflection.py +++ b/examples/25_tilt_driven_vertical_wake_deflection.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane """ @@ -17,10 +17,10 @@ # Initialize two FLORIS objects: one with 5 degrees of tilt (fixed across all # wind speeds) and one with 15 degrees of tilt (fixed across all wind speeds). -fi_5 = FlorisInterface("inputs_floating/emgauss_floating_fixedtilt5.yaml") -fi_15 = FlorisInterface("inputs_floating/emgauss_floating_fixedtilt15.yaml") +fmodel_5 = FlorisModel("inputs_floating/emgauss_floating_fixedtilt5.yaml") +fmodel_15 = FlorisModel("inputs_floating/emgauss_floating_fixedtilt15.yaml") -D = fi_5.floris.farm.rotor_diameters[0] +D = fmodel_5.core.farm.rotor_diameters[0] num_in_row = 5 @@ -46,10 +46,10 @@ powers = np.zeros((2, num_in_row)) # Calculate wakes, powers, plot -for i, (fi, tilt) in enumerate(zip([fi_5, fi_15], [5, 15])): +for i, (fmodel, tilt) in enumerate(zip([fmodel_5, fmodel_15], [5, 15])): # Farm layout and wind conditions - fi.set( + fmodel.set( layout_x=[x * 5.0 * D for x in range(num_in_row)], layout_y=[0.0]*num_in_row, wind_speeds=[8.0], @@ -57,11 +57,11 @@ ) # Flow solve and power computation - fi.run() - powers[i,:] = fi.get_turbine_powers().flatten() + fmodel.run() + powers[i,:] = fmodel.get_turbine_powers().flatten() # Compute flow slices - y_plane = fi.calculate_y_plane( + y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=streamwise_plane_location, diff --git a/examples/26_empirical_gauss_velocity_deficit_parameters.py b/examples/26_empirical_gauss_velocity_deficit_parameters.py index 8d7d73857..a3c43343a 100644 --- a/examples/26_empirical_gauss_velocity_deficit_parameters.py +++ b/examples/26_empirical_gauss_velocity_deficit_parameters.py @@ -4,8 +4,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import plot_rotor_values, visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import plot_rotor_values, visualize_cut_plane """ @@ -13,10 +13,6 @@ velocity deficit model and their effects on the wind turbine wake. """ -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. - # Options show_flow_cuts = True num_in_row = 5 @@ -24,8 +20,8 @@ yaw_angles = np.zeros((1, num_in_row)) # Define function for visualizing wakes -def generate_wake_visualization(fi: FlorisInterface, title=None): - # Using the FlorisInterface functions, get 2D slices. +def generate_wake_visualization(fmodel: FlorisModel, title=None): + # Using the FlorisModel functions, get 2D slices. x_bounds = [-500, 3000] y_bounds = [-250, 250] z_bounds = [0.001, 500] @@ -36,7 +32,7 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): min_ws = 4 max_ws = 10 - horizontal_plane = fi.calculate_horizontal_plane( + horizontal_plane = fmodel.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=horizontal_plane_location, @@ -44,7 +40,7 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): y_bounds=y_bounds, yaw_angles=yaw_angles ) - y_plane = fi.calculate_y_plane( + y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=streamwise_plane_location, @@ -55,7 +51,7 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): cross_planes = [] for cpl in cross_plane_locations: cross_planes.append( - fi.calculate_cross_plane( + fmodel.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=cpl @@ -101,9 +97,9 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): ## Main script # Load input yaml and define farm layout -fi = FlorisInterface("inputs/emgauss.yaml") -D = fi.floris.farm.rotor_diameters[0] -fi.set( +fmodel = FlorisModel("inputs/emgauss.yaml") +D = fmodel.core.farm.rotor_diameters[0] +fmodel.set( layout_x=[x*5.0*D for x in range(num_in_row)], layout_y=[0.0]*num_in_row, wind_speeds=[8.0], @@ -111,13 +107,13 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): ) # Save dictionary to modify later -fi_dict = fi.floris.as_dict() +fmodel_dict = fmodel.core.as_dict() # Run wake calculation -fi.run() +fmodel.run() # Look at the powers of each turbine -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 fig0, ax0 = plt.subplots(1,1) width = 0.1 @@ -131,20 +127,20 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): # Visualize wakes if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Increase the base recovery rate -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ ['wake_expansion_rates'] = [0.03, 0.015] -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0] ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -153,25 +149,25 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Add new expansion rate -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ ['wake_expansion_rates'] = \ - fi_dict['wake']['wake_velocity_parameters']['empirical_gauss']\ + fmodel_dict['wake']['wake_velocity_parameters']['empirical_gauss']\ ['wake_expansion_rates'] + [0.0] -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ ['breakpoints_D'] = [5, 10] -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0] ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -180,20 +176,20 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Increase the wake-induced mixing gain -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ ['mixing_gain_velocity'] = 3.0 -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0] ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -202,7 +198,7 @@ def generate_wake_visualization(fi: FlorisInterface, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Power plot aesthetics ax0.set_xticks(range(num_in_row)) diff --git a/examples/27_empirical_gauss_deflection_parameters.py b/examples/27_empirical_gauss_deflection_parameters.py index cb59ee821..79bdee9f8 100644 --- a/examples/27_empirical_gauss_deflection_parameters.py +++ b/examples/27_empirical_gauss_deflection_parameters.py @@ -4,8 +4,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.flow_visualization import plot_rotor_values, visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import plot_rotor_values, visualize_cut_plane """ @@ -13,8 +13,8 @@ deflection model and their effects on the wind turbine wake. """ -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive +# Initialize FLORIS with the given input file. +# For basic usage, FlorisModel provides a simplified and expressive # entry point to the simulation routines. # Options @@ -27,8 +27,8 @@ print("Turbine yaw angles (degrees): ", yaw_angles[0]) # Define function for visualizing wakes -def generate_wake_visualization(fi, title=None): - # Using the FlorisInterface functions, get 2D slices. +def generate_wake_visualization(fmodel, title=None): + # Using the FlorisModel functions, get 2D slices. x_bounds = [-500, 3000] y_bounds = [-250, 250] z_bounds = [0.001, 500] @@ -39,7 +39,7 @@ def generate_wake_visualization(fi, title=None): min_ws = 4 max_ws = 10 - horizontal_plane = fi.calculate_horizontal_plane( + horizontal_plane = fmodel.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=horizontal_plane_location, @@ -47,7 +47,7 @@ def generate_wake_visualization(fi, title=None): y_bounds=y_bounds, yaw_angles=yaw_angles ) - y_plane = fi.calculate_y_plane( + y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=streamwise_plane_location, @@ -58,7 +58,7 @@ def generate_wake_visualization(fi, title=None): cross_planes = [] for cpl in cross_plane_locations: cross_planes.append( - fi.calculate_cross_plane( + fmodel.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=cpl @@ -105,9 +105,9 @@ def generate_wake_visualization(fi, title=None): ## Main script # Load input yaml and define farm layout -fi = FlorisInterface("inputs/emgauss.yaml") -D = fi.floris.farm.rotor_diameters[0] -fi.set( +fmodel = FlorisModel("inputs/emgauss.yaml") +D = fmodel.core.farm.rotor_diameters[0] +fmodel.set( layout_x=[x*5.0*D for x in range(num_in_row)], layout_y=[0.0]*num_in_row, wind_speeds=[8.0], @@ -116,13 +116,13 @@ def generate_wake_visualization(fi, title=None): ) # Save dictionary to modify later -fi_dict = fi.floris.as_dict() +fmodel_dict = fmodel.core.as_dict() # Run wake calculation -fi.run() +fmodel.run() # Look at the powers of each turbine -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 fig0, ax0 = plt.subplots(1,1) width = 0.1 @@ -136,23 +136,23 @@ def generate_wake_visualization(fi, title=None): # Visualize wakes if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Increase the maximum deflection attained -fi_dict_mod = copy.deepcopy(fi_dict) +fmodel_dict_mod = copy.deepcopy(fmodel_dict) -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['horizontal_deflection_gain_D'] = 5.0 -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0], yaw_angles=yaw_angles, ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -161,22 +161,22 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Add (increase) influence of wake added mixing -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['mixing_gain_deflection'] = 100.0 -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0], yaw_angles=yaw_angles, ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -185,25 +185,25 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Add (increase) the yaw-added mixing contribution -fi_dict_mod = copy.deepcopy(fi_dict) +fmodel_dict_mod = copy.deepcopy(fmodel_dict) # Include a WIM gain so that YAM is reflected in deflection as well # as deficit -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['mixing_gain_deflection'] = 100.0 -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['yaw_added_mixing_gain'] = 1.0 -fi = FlorisInterface(fi_dict_mod) -fi.set( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], wind_directions=[270.0], yaw_angles=yaw_angles, ) -fi.run() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -212,7 +212,7 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Power plot aesthetics ax0.set_xticks(range(num_in_row)) diff --git a/examples/28_extract_wind_speed_at_points.py b/examples/28_extract_wind_speed_at_points.py index 52c28c9ca..7c9b9adbc 100644 --- a/examples/28_extract_wind_speed_at_points.py +++ b/examples/28_extract_wind_speed_at_points.py @@ -2,12 +2,12 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ This example demonstrates the use of the sample_flow_at_points method of -FlorisInterface. sample_flow_at_points extracts the wind speed +FlorisModel. sample_flow_at_points extracts the wind speed information at user-specified locations in the flow. Specifically, this example returns the wind speed at a single x, y @@ -26,21 +26,21 @@ met_mast_option = 0 # Try 0, 1, 2, 3 # Instantiate FLORIS model -fi = FlorisInterface("inputs/"+floris_model+".yaml") +fmodel = FlorisModel("inputs/"+floris_model+".yaml") # Set up a two-turbine farm D = 126 -fi.set(layout_x=[0, 3 * D], layout_y=[0, 3 * D]) +fmodel.set(layout_x=[0, 3 * D], layout_y=[0, 3 * D]) fig, ax = plt.subplots(1,2) fig.set_size_inches(10,4) -ax[0].scatter(fi.layout_x, fi.layout_y, color="black", label="Turbine") +ax[0].scatter(fmodel.layout_x, fmodel.layout_y, color="black", label="Turbine") # Set the wind direction to run 360 degrees wd_array = np.arange(0, 360, 1) ws_array = 8.0 * np.ones_like(wd_array) ti_array = 0.06 * np.ones_like(wd_array) -fi.set(wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array) +fmodel.set(wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array) # Simulate a met mast in between the turbines if met_mast_option == 0: @@ -59,7 +59,7 @@ points_z = [30, 90, 150, 250] # Collect the points -u_at_points = fi.sample_flow_at_points(points_x, points_y, points_z) +u_at_points = fmodel.sample_flow_at_points(points_x, points_y, points_z) ax[0].scatter(points_x, points_y, color="red", marker="x", label="Met mast") ax[0].grid() diff --git a/examples/29_floating_vs_fixedbottom_farm.py b/examples/29_floating_vs_fixedbottom_farm.py index 044d24342..e04ac3f98 100644 --- a/examples/29_floating_vs_fixedbottom_farm.py +++ b/examples/29_floating_vs_fixedbottom_farm.py @@ -4,8 +4,8 @@ import pandas as pd from scipy.interpolate import NearestNDInterpolator -import floris.tools.flow_visualization as flowviz -from floris.tools import FlorisInterface +import floris.flow_visualization as flowviz +from floris import FlorisModel """ @@ -27,32 +27,32 @@ the Empirical Gaussian wake model to show the effects of floating turbines on both turbine power and wake development. -fi_fixed: Fixed bottom turbine (no tilt variation with wind speed) -fi_floating: Floating turbine (tilt varies with wind speed) +fmodel_fixed: Fixed bottom turbine (no tilt variation with wind speed) +fmodel_floating: Floating turbine (tilt varies with wind speed) """ # Declare the Floris Interface for fixed bottom, provide layout -fi_fixed = FlorisInterface("inputs_floating/emgauss_fixed.yaml") -fi_floating = FlorisInterface("inputs_floating/emgauss_floating.yaml") +fmodel_fixed = FlorisModel("inputs_floating/emgauss_fixed.yaml") +fmodel_floating = FlorisModel("inputs_floating/emgauss_floating.yaml") x, y = np.meshgrid(np.linspace(0, 4*630., 5), np.linspace(0, 3*630., 4)) x = x.flatten() y = y.flatten() -for fi in [fi_fixed, fi_floating]: - fi.set(layout_x=x, layout_y=y) +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set(layout_x=x, layout_y=y) # Compute a single wind speed and direction, power and wakes -for fi in [fi_fixed, fi_floating]: - fi.set( +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set( layout_x=x, layout_y=y, wind_speeds=[10], wind_directions=[270], turbulence_intensities=[0.06], ) - fi.run() + fmodel.run() -powers_fixed = fi_fixed.get_turbine_powers() -powers_floating = fi_floating.get_turbine_powers() +powers_fixed = fmodel_fixed.get_turbine_powers() +powers_floating = fmodel_floating.get_turbine_powers() power_difference = powers_floating - powers_fixed # Show the power differences @@ -78,16 +78,16 @@ # Visualize flows (see also 02_visualizations.py) horizontal_planes = [] y_planes = [] -for fi in [fi_fixed, fi_floating]: +for fmodel in [fmodel_fixed, fmodel_floating]: horizontal_planes.append( - fi.calculate_horizontal_plane( + fmodel.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=90.0, ) ) y_planes.append( - fi.calculate_y_plane( + fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=0.0, @@ -118,16 +118,16 @@ freq = freq_interp(wd_grid, ws_grid).flatten() freq = freq / np.sum(freq) -for fi in [fi_fixed, fi_floating]: - fi.set( +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set( wind_directions=wd_grid.flatten(), wind_speeds= ws_grid.flatten(), turbulence_intensities=0.06 * np.ones_like(wd_grid.flatten()) ) # Compute the AEP -aep_fixed = fi_fixed.get_farm_AEP(freq=freq) -aep_floating = fi_floating.get_farm_AEP(freq=freq) +aep_fixed = fmodel_fixed.get_farm_AEP(freq=freq) +aep_floating = fmodel_floating.get_farm_AEP(freq=freq) print("Farm AEP (fixed bottom): {:.3f} GWh".format(aep_fixed / 1.0e9)) print("Farm AEP (floating): {:.3f} GWh".format(aep_floating / 1.0e9)) print( diff --git a/examples/30_multi_dimensional_cp_ct.py b/examples/30_multi_dimensional_cp_ct.py index 3eebf0854..e33ca31d2 100644 --- a/examples/30_multi_dimensional_cp_ct.py +++ b/examples/30_multi_dimensional_cp_ct.py @@ -1,7 +1,7 @@ import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -36,31 +36,31 @@ and used to select the interpolant at each turbine. Also note in the example below that there is a specific method for computing powers when -using turbines with multi-dimensional Cp/Ct data under FlorisInterface, called +using turbines with multi-dimensional Cp/Ct data under FlorisModel, called 'get_turbine_powers_multidim'. The normal 'get_turbine_powers' method will not work. """ -# Initialize FLORIS with the given input file via FlorisInterface. -fi = FlorisInterface("inputs/gch_multi_dim_cp_ct.yaml") +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("inputs/gch_multi_dim_cp_ct.yaml") # Convert to a simple two turbine layout -fi.set(layout_x=[0., 500.], layout_y=[0., 0.]) +fmodel.set(layout_x=[0., 500.], layout_y=[0., 0.]) # Single wind speed and wind direction print('\n========================= Single Wind Direction and Wind Speed =========================') # Get the turbine powers assuming 1 wind speed and 1 wind direction -fi.set(wind_directions=[270.0], wind_speeds=[8.0], turbulence_intensities=[0.06]) +fmodel.set(wind_directions=[270.0], wind_speeds=[8.0], turbulence_intensities=[0.06]) # Set the yaw angles to 0 yaw_angles = np.zeros([1, 2]) # 1 wind direction and wind speed, 2 turbines -fi.set(yaw_angles=yaw_angles) +fmodel.set(yaw_angles=yaw_angles) # Calculate -fi.run() +fmodel.run() # Get the turbine powers -turbine_powers = fi.get_turbine_powers() / 1000.0 +turbine_powers = fmodel.get_turbine_powers() / 1000.0 print("The turbine power matrix should be of dimensions 1 findex X 2 Turbines") print(turbine_powers) print("Shape: ",turbine_powers.shape) @@ -73,14 +73,14 @@ turbulence_intensities = np.array([0.06, 0.06, 0.06]) yaw_angles = np.zeros([3, 2]) # 3 wind directions/ speeds, 2 turbines -fi.set( +fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, turbulence_intensities=turbulence_intensities, yaw_angles=yaw_angles ) -fi.run() -turbine_powers = fi.get_turbine_powers() / 1000.0 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1000.0 print("The turbine power matrix should be of dimensions 3 findex X 2 Turbines") print(turbine_powers) print("Shape: ",turbine_powers.shape) @@ -93,14 +93,14 @@ turbulence_intensities = 0.06 * np.ones_like(wind_speeds) yaw_angles = np.zeros([9, 2]) # 9 wind directions/ speeds, 2 turbines -fi.set( +fmodel.set( wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities, yaw_angles=yaw_angles ) -fi.run() -turbine_powers = fi.get_turbine_powers()/1000. +fmodel.run() +turbine_powers = fmodel.get_turbine_powers()/1000. print("The turbine power matrix should be of dimensions 9 WD/WS X 2 Turbines") print(turbine_powers) print("Shape: ",turbine_powers.shape) diff --git a/examples/31_multi_dimensional_cp_ct_2Hs.py b/examples/31_multi_dimensional_cp_ct_2Hs.py index df5d4d171..56bb6fc20 100644 --- a/examples/31_multi_dimensional_cp_ct_2Hs.py +++ b/examples/31_multi_dimensional_cp_ct_2Hs.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -13,46 +13,46 @@ values of the original Cp/Ct data for the IEA 15MW turbine. """ -# Initialize FLORIS with the given input file via FlorisInterface. -fi = FlorisInterface("inputs/gch_multi_dim_cp_ct.yaml") +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("inputs/gch_multi_dim_cp_ct.yaml") -# Make a second FLORIS interface with a different setting for Hs. +# Make a second Floris instance with a different setting for Hs. # Note the multi-cp-ct file (iea_15MW_multi_dim_Tp_Hs.csv) # for the turbine model iea_15MW_floating_multi_dim_cp_ct.yaml # Defines Hs at 1 and 5. # The value in gch_multi_dim_cp_ct.yaml is 3.01 which will map # to 5 as the nearer value, so we set the other case to 1 # for contrast. -fi_dict_mod = fi.floris.as_dict() -fi_dict_mod['flow_field']['multidim_conditions']['Hs'] = 1.0 -fi_hs_1 = FlorisInterface(fi_dict_mod) +fmodel_dict_mod = fmodel.core.as_dict() +fmodel_dict_mod['flow_field']['multidim_conditions']['Hs'] = 1.0 +fmodel_hs_1 = FlorisModel(fmodel_dict_mod) # Set both cases to 3 turbine layout -fi.set(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) -fi_hs_1.set(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) +fmodel.set(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) +fmodel_hs_1.set(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) # Use a sweep of wind speeds wind_speeds = np.arange(5, 20, 1.0) wind_directions = 270.0 * np.ones_like(wind_speeds) turbulence_intensities = 0.06 * np.ones_like(wind_speeds) -fi.set( +fmodel.set( wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities ) -fi_hs_1.set( +fmodel_hs_1.set( wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities ) # Calculate wakes with baseline yaw -fi.run() -fi_hs_1.run() +fmodel.run() +fmodel_hs_1.run() # Collect the turbine powers in kW -turbine_powers = fi.get_turbine_powers()/1000. -turbine_powers_hs_1 = fi_hs_1.get_turbine_powers()/1000. +turbine_powers = fmodel.get_turbine_powers()/1000. +turbine_powers_hs_1 = fmodel_hs_1.get_turbine_powers()/1000. # Plot the power in each case and the difference in power fig, axarr = plt.subplots(1,3,sharex=True,figsize=(12,4)) diff --git a/examples/32_plot_velocity_deficit_profiles.py b/examples/32_plot_velocity_deficit_profiles.py index 490809571..a0b2949e0 100644 --- a/examples/32_plot_velocity_deficit_profiles.py +++ b/examples/32_plot_velocity_deficit_profiles.py @@ -3,9 +3,9 @@ import numpy as np from matplotlib import ticker -import floris.tools.flow_visualization as flowviz -from floris.tools import cut_plane, FlorisInterface -from floris.tools.flow_visualization import VelocityProfilesFigure +import floris.flow_visualization as flowviz +from floris import cut_plane, FlorisModel +from floris.flow_visualization import VelocityProfilesFigure from floris.utilities import reverse_rotate_coordinates_rel_west @@ -37,7 +37,7 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): x2 = np.array([0.0, quiver_length + 0.35 * D]) x3 = np.array([90.0, 90.0]) x, y, _ = reverse_rotate_coordinates_rel_west( - fi.floris.flow_field.wind_directions, + fmodel.core.flow_field.wind_directions, x1[None, :], x2[None, :], x3[None, :], @@ -54,8 +54,8 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): hub_height = 90.0 homogeneous_wind_speed = 8.0 - fi = FlorisInterface("inputs/gch.yaml") - fi.set(layout_x=[0.0], layout_y=[0.0]) + fmodel = FlorisModel("inputs/gch.yaml") + fmodel.set(layout_x=[0.0], layout_y=[0.0]) # ------------------------------ Single-turbine layout ------------------------------ # We first show how to sample and plot velocity deficit profiles on a single-turbine layout. @@ -63,13 +63,13 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): downstream_dists = D * np.array([3, 5, 7]) # Sample three profiles along three corresponding lines that are all parallel to the y-axis # (cross-stream direction). The streamwise location of each line is given in `downstream_dists`. - profiles = fi.sample_velocity_deficit_profiles( + profiles = fmodel.sample_velocity_deficit_profiles( direction='cross-stream', downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, ) - horizontal_plane = fi.calculate_horizontal_plane(height=hub_height) + horizontal_plane = fmodel.calculate_horizontal_plane(height=hub_height) fig, ax = plt.subplots(figsize=(6.4, 3)) flowviz.visualize_cut_plane(horizontal_plane, ax) colors = ['b', 'g', 'c'] @@ -95,10 +95,10 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # Change velocity model to jensen, get the velocity deficit profiles, # and add them to the figure. - floris_dict = fi.floris.as_dict() + floris_dict = fmodel.core.as_dict() floris_dict['wake']['model_strings']['velocity_model'] = 'jensen' - fi = FlorisInterface(floris_dict) - profiles = fi.sample_velocity_deficit_profiles( + fmodel = FlorisModel(floris_dict) + profiles = fmodel.sample_velocity_deficit_profiles( direction='cross-stream', downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, @@ -125,16 +125,16 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # (i.e. where to start sampling the profiles). wind_direction = 315.0 # Try to change this downstream_dists = D * np.array([3, 5]) - floris_dict = fi.floris.as_dict() + floris_dict = fmodel.core.as_dict() floris_dict['wake']['model_strings']['velocity_model'] = 'gauss' - fi = FlorisInterface(floris_dict) + fmodel = FlorisModel(floris_dict) # Let (x_t1, y_t1) be the location of the second turbine x_t1 = 2 * D y_t1 = -2 * D - fi.set(wind_directions=[wind_direction], layout_x=[0.0, x_t1], layout_y=[0.0, y_t1]) + fmodel.set(wind_directions=[wind_direction], layout_x=[0.0, x_t1], layout_y=[0.0, y_t1]) # Extract profiles at a set of downstream distances from the starting point (x_start, y_start) - cross_profiles = fi.sample_velocity_deficit_profiles( + cross_profiles = fmodel.sample_velocity_deficit_profiles( direction='cross-stream', downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, @@ -142,7 +142,10 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): y_start=y_t1, ) - horizontal_plane = fi.calculate_horizontal_plane(height=hub_height, x_bounds=[-2 * D, 9 * D]) + horizontal_plane = fmodel.calculate_horizontal_plane( + height=hub_height, + x_bounds=[-2 * D, 9 * D] + ) ax = flowviz.visualize_cut_plane(horizontal_plane) colors = ['b', 'g', 'c'] for i, profile in enumerate(cross_profiles): @@ -162,7 +165,7 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # locations as before. We stay directly downstream of the turbine (i.e. x2 = 0). These # profiles are almost identical to the cross-stream profiles. However, we now explicitly # set the profile range. The default range is [-2 * D, 2 * D]. - vertical_profiles = fi.sample_velocity_deficit_profiles( + vertical_profiles = fmodel.sample_velocity_deficit_profiles( direction='vertical', profile_range=[-1.5 * D, 1.5 * D], downstream_dists=downstream_dists, diff --git a/examples/33_specify_turbine_power_curve.py b/examples/33_specify_turbine_power_curve.py index f10e4f7cd..420f5aeab 100644 --- a/examples/33_specify_turbine_power_curve.py +++ b/examples/33_specify_turbine_power_curve.py @@ -2,7 +2,7 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface +from floris import FlorisModel from floris.turbine_library import build_cosine_loss_turbine_dict @@ -39,12 +39,12 @@ ref_tilt=5 ) -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") wind_speeds = np.linspace(1, 15, 100) wind_directions = 270 * np.ones_like(wind_speeds) turbulence_intensities = 0.06 * np.ones_like(wind_speeds) # Replace the turbine(s) in the FLORIS model with the created one -fi.set( +fmodel.set( layout_x=[0], layout_y=[0], wind_directions=wind_directions, @@ -52,9 +52,9 @@ turbulence_intensities=turbulence_intensities, turbine_type=[turbine_dict] ) -fi.run() +fmodel.run() -powers = fi.get_farm_power() +powers = fmodel.get_farm_power() specified_powers = ( np.array(turbine_data_dict["power_coefficient"]) diff --git a/examples/34_wind_data.py b/examples/34_wind_data.py index 79469c988..3a4d56fe5 100644 --- a/examples/34_wind_data.py +++ b/examples/34_wind_data.py @@ -1,8 +1,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import ( - FlorisInterface, +from floris import ( + FlorisModel, TimeSeries, WindRose, ) @@ -59,28 +59,28 @@ plt.tight_layout() # Now set up a FLORIS model and initialize it using the time series and wind rose -fi = FlorisInterface("inputs/gch.yaml") -fi.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) +fmodel = FlorisModel("inputs/gch.yaml") +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) -fi_time_series = fi.copy() -fi_wind_rose = fi.copy() -fi_wind_ti_rose = fi.copy() +fmodel_time_series = fmodel.copy() +fmodel_wind_rose = fmodel.copy() +fmodel_wind_ti_rose = fmodel.copy() -fi_time_series.set(wind_data=time_series) -fi_wind_rose.set(wind_data=wind_rose) -fi_wind_ti_rose.set(wind_data=wind_ti_rose) +fmodel_time_series.set(wind_data=time_series) +fmodel_wind_rose.set(wind_data=wind_rose) +fmodel_wind_ti_rose.set(wind_data=wind_ti_rose) -fi_time_series.run() -fi_wind_rose.run() -fi_wind_ti_rose.run() +fmodel_time_series.run() +fmodel_wind_rose.run() +fmodel_wind_ti_rose.run() -time_series_power = fi_time_series.get_farm_power() -wind_rose_power = fi_wind_rose.get_farm_power() -wind_ti_rose_power = fi_wind_ti_rose.get_farm_power() +time_series_power = fmodel_time_series.get_farm_power() +wind_rose_power = fmodel_wind_rose.get_farm_power() +wind_ti_rose_power = fmodel_wind_ti_rose.get_farm_power() -time_series_aep = fi_time_series.get_farm_AEP_with_wind_data(time_series) -wind_rose_aep = fi_wind_rose.get_farm_AEP_with_wind_data(wind_rose) -wind_ti_rose_aep = fi_wind_ti_rose.get_farm_AEP_with_wind_data(wind_ti_rose) +time_series_aep = fmodel_time_series.get_farm_AEP_with_wind_data(time_series) +wind_rose_aep = fmodel_wind_rose.get_farm_AEP_with_wind_data(wind_rose) +wind_ti_rose_aep = fmodel_wind_ti_rose.get_farm_AEP_with_wind_data(wind_ti_rose) print(f"AEP from TimeSeries {time_series_aep / 1e9:.2f} GWh") print(f"AEP from WindRose {wind_rose_aep / 1e9:.2f} GWh") diff --git a/examples/35_sweep_ti.py b/examples/35_sweep_ti.py index 23942150e..5bf2ffa34 100644 --- a/examples/35_sweep_ti.py +++ b/examples/35_sweep_ti.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import ( - FlorisInterface, +from floris import ( + FlorisModel, TimeSeries, WindRose, ) @@ -29,10 +29,10 @@ # Now set up a FLORIS model and initialize it using the time -fi = FlorisInterface("inputs/gch.yaml") -fi.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0], wind_data=time_series) -fi.run() -turbine_power = fi.get_turbine_powers() +fmodel = FlorisModel("inputs/gch.yaml") +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0], wind_data=time_series) +fmodel.run() +turbine_power = fmodel.get_turbine_powers() fig, axarr = plt.subplots(2, 1, sharex=True, figsize=(6, 6)) ax = axarr[0] diff --git a/examples/36_generate_ti.py b/examples/36_generate_ti.py index 3c6d8a9bf..317bc8dbe 100644 --- a/examples/36_generate_ti.py +++ b/examples/36_generate_ti.py @@ -2,8 +2,8 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import ( - FlorisInterface, +from floris import ( + FlorisModel, TimeSeries, WindRose, ) diff --git a/examples/40_test_derating.py b/examples/40_test_derating.py index 4385ff4a0..2a7260167 100644 --- a/examples/40_test_derating.py +++ b/examples/40_test_derating.py @@ -3,7 +3,7 @@ import numpy as np import yaml -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -12,39 +12,39 @@ """ # Grab model of FLORIS and update to deratable turbines -fi = FlorisInterface("inputs/gch.yaml") +fmodel = FlorisModel("inputs/gch.yaml") with open(str( - fi.floris.as_dict()["farm"]["turbine_library_path"] / - (fi.floris.as_dict()["farm"]["turbine_type"][0] + ".yaml") + fmodel.core.as_dict()["farm"]["turbine_library_path"] / + (fmodel.core.as_dict()["farm"]["turbine_type"][0] + ".yaml") )) as t: turbine_type = yaml.safe_load(t) turbine_type["power_thrust_model"] = "simple-derating" # Convert to a simple two turbine layout with derating turbines -fi.set(layout_x=[0, 1000.0], layout_y=[0.0, 0.0], turbine_type=[turbine_type]) +fmodel.set(layout_x=[0, 1000.0], layout_y=[0.0, 0.0], turbine_type=[turbine_type]) # Set the wind directions and speeds to be constant over n_findex = N time steps N = 50 -fi.set( +fmodel.set( wind_directions=270 * np.ones(N), wind_speeds=10.0 * np.ones(N), turbulence_intensities=0.06 * np.ones(N) ) -fi.run() -turbine_powers_orig = fi.get_turbine_powers() +fmodel.run() +turbine_powers_orig = fmodel.get_turbine_powers() # Add derating power_setpoints = np.tile(np.linspace(1, 6e6, N), 2).reshape(2, N).T -fi.set(power_setpoints=power_setpoints) -fi.run() -turbine_powers_derated = fi.get_turbine_powers() +fmodel.set(power_setpoints=power_setpoints) +fmodel.run() +turbine_powers_derated = fmodel.get_turbine_powers() # Compute available power at downstream turbine power_setpoints_2 = np.array([np.linspace(1, 6e6, N), np.full(N, None)]).T -fi.set(power_setpoints=power_setpoints_2) -fi.run() -turbine_powers_avail_ds = fi.get_turbine_powers()[:,1] +fmodel.set(power_setpoints=power_setpoints_2) +fmodel.run() +turbine_powers_avail_ds = fmodel.get_turbine_powers()[:,1] # Plot the results fig, ax = plt.subplots(1, 1) @@ -97,7 +97,7 @@ [2e6, None,], [None, 1e6] ]) -fi.set( +fmodel.set( wind_directions=270 * np.ones(len(yaw_angles)), wind_speeds=10.0 * np.ones(len(yaw_angles)), turbulence_intensities=0.06 * np.ones(len(yaw_angles)), @@ -105,8 +105,8 @@ yaw_angles=yaw_angles, power_setpoints=power_setpoints, ) -fi.run() -turbine_powers = fi.get_turbine_powers() +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() print(turbine_powers) plt.show() diff --git a/examples/41_test_disable_turbines.py b/examples/41_test_disable_turbines.py index 717bb02e5..3dadc1e0d 100644 --- a/examples/41_test_disable_turbines.py +++ b/examples/41_test_disable_turbines.py @@ -3,7 +3,7 @@ import numpy as np import yaml -from floris.tools import FlorisInterface +from floris import FlorisModel """ @@ -12,19 +12,19 @@ during a simulation. """ -# Initialize the FLORIS interface -fi = FlorisInterface("inputs/gch.yaml") +# Initialize FLORIS +fmodel = FlorisModel("inputs/gch.yaml") # Change to the mixed model turbine with open( str( - fi.floris.as_dict()["farm"]["turbine_library_path"] - / (fi.floris.as_dict()["farm"]["turbine_type"][0] + ".yaml") + fmodel.core.as_dict()["farm"]["turbine_library_path"] + / (fmodel.core.as_dict()["farm"]["turbine_type"][0] + ".yaml") ) ) as t: turbine_type = yaml.safe_load(t) turbine_type["power_thrust_model"] = "mixed" -fi.set(turbine_type=[turbine_type]) +fmodel.set(turbine_type=[turbine_type]) # Consider a wind farm of 3 aligned wind turbines layout = np.array([[0.0, 0.0], [500.0, 0.0], [1000.0, 0.0]]) @@ -43,7 +43,7 @@ # ------------------------------------------ # Reinitialize flow field -fi.set( +fmodel.set( layout_x=layout[:, 0], layout_y=layout[:, 1], wind_directions=wind_directions, @@ -53,15 +53,15 @@ ) # # Compute wakes -fi.run() +fmodel.run() # Results # ------------------------------------------ # Get powers and effective wind speeds -turbine_powers = fi.get_turbine_powers() +turbine_powers = fmodel.get_turbine_powers() turbine_powers = np.round(turbine_powers * 1e-3, decimals=2) -effective_wind_speeds = fi.turbine_average_velocities +effective_wind_speeds = fmodel.turbine_average_velocities # Plot the results diff --git a/examples/xx_add_ti_to_emg.py b/examples/xx_add_ti_to_emg.py new file mode 100644 index 000000000..a79a65bac --- /dev/null +++ b/examples/xx_add_ti_to_emg.py @@ -0,0 +1,243 @@ +""" Script for reconsidering TI recovery in the EMG model + + +""" + + +from typing import ( + Any, + Dict, + List, + Optional, +) + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +from floris import FlorisModel, WindRose +from floris.layout_visualization import ( + plot_turbine_labels, + plot_turbine_points, + plot_waking_directions, +) + + +# Tuning parameters for new ti model +atmospheric_ti_gain = 0.0 # note default: 0.0 +wake_expansion_rates = [0.023, 0.008] # note default: [0.023, 0.008] +breakpoints_D = [10] # Node default: [10] + +# Layout parameters +n_col = 6 # Number of columns +n_t = 10 # Number of turbines per column +dist_c = 7.0 # Distance between columns +dist_t = 3.0 # Distance between turbines + +# Atmospheric parameters +wind_directions = np.arange(250, 291, 1.0) +wind_speeds = np.array([8.0, 9.0]) + +# Parameters +D = 126.0 + + +def nested_get(dic: Dict[str, Any], keys: List[str]) -> Any: + """Get a value from a nested dictionary using a list of keys. + Based on: stackoverflow.com/questions/14692690/access-nested-dictionary-items-via-a-list-of-keys + + Args: + dic (Dict[str, Any]): The dictionary to get the value from. + keys (List[str]): A list of keys to traverse the dictionary. + + Returns: + Any: The value at the end of the key traversal. + """ + for key in keys: + dic = dic[key] + return dic + + +def nested_set(dic: Dict[str, Any], keys: List[str], value: Any, idx: Optional[int] = None) -> None: + """Set a value in a nested dictionary using a list of keys. + Based on: stackoverflow.com/questions/14692690/access-nested-dictionary-items-via-a-list-of-keys + + Args: + dic (Dict[str, Any]): The dictionary to set the value in. + keys (List[str]): A list of keys to traverse the dictionary. + value (Any): The value to set. + idx (Optional[int], optional): If the value is an list, the index to change. + Defaults to None. + """ + dic_in = dic.copy() + + for key in keys[:-1]: + dic = dic.setdefault(key, {}) + if idx is None: + # Parameter is a scaler, set directly + dic[keys[-1]] = value + else: + # Parameter is a list, need to first get the list, change the values at idx + + # # Get the underlying list + par_list = nested_get(dic_in, keys) + par_list[idx] = value + dic[keys[-1]] = par_list + + +def set_fi_param( + fm_in: FlorisModel, param: List[str], value: Any, param_idx: Optional[int] = None +) -> FlorisModel: + """Set a parameter in a FlorisInterface object. + + Args: + fi_in (FlorisInterface): The FlorisInterface object to modify. + param (List[str]): A list of keys to traverse the FlorisInterface dictionary. + value (Any): The value to set. + idx (Optional[int], optional): The index to set the value at. Defaults to None. + + Returns: + FlorisInterface: The modified FlorisInterface object. + """ + fm_dict_mod = fm_in.core.as_dict() + nested_set(fm_dict_mod, param, value, param_idx) + return FlorisModel(fm_dict_mod) + + +# Initialize FLORIS with the given input file. +# The Floris class is the entry point for most usage. +fmodel_emg = FlorisModel("inputs/emgauss.yaml") + +# Get a copy for the ti-enabled case +fmodel_emg_ti = fmodel_emg.copy() + +# Get the dictionary +# fm_dict = fmodel_emg.core.as_dict() +# print(fm_dict['wake']['wake_velocity_parameters']['empirical_gauss'].keys()) +# Update the parameters +fmodel_emg_ti = set_fi_param( + fm_in=fmodel_emg_ti, + param=["wake", "wake_velocity_parameters", "empirical_gauss", "wake_expansion_rates"], + value=wake_expansion_rates[0], + param_idx=0, +) +fmodel_emg_ti = set_fi_param( + fm_in=fmodel_emg_ti, + param=["wake", "wake_velocity_parameters", "empirical_gauss", "wake_expansion_rates"], + value=wake_expansion_rates[1], + param_idx=1, +) +fmodel_emg_ti = set_fi_param( + fm_in=fmodel_emg_ti, + param=["wake", "wake_velocity_parameters", "empirical_gauss", "breakpoints_D"], + value=breakpoints_D[0], + param_idx=0, +) +fmodel_emg_ti = set_fi_param( + fm_in=fmodel_emg_ti, + param=["wake", "wake_turbulence_parameters", "wake_induced_mixing", "atmospheric_ti_gain"], + value=atmospheric_ti_gain, +) + + +# Use a nested list comprehension to create the layout_x and layout_y arrays +layout_x = [dist_c * D * i for i in range(n_col) for j in range(n_t)] +layout_y = [dist_t * D * j for i in range(n_col) for j in range(n_t)] + +# Set the wind farm layout using the set method +fmodel_emg.set(layout_x=layout_x, layout_y=layout_y) +fmodel_emg_ti.set(layout_x=layout_x, layout_y=layout_y) + +# Show the layout of the farm +fig, ax = plt.subplots() +plot_turbine_points(fmodel_emg, ax) +plot_turbine_labels(fmodel_emg, ax) +plot_waking_directions(fmodel_emg, ax, limit_dist_D=dist_c * 1.01) + +# Set up a wind rose input +wind_rose = WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + ti_table=0.06, +) +fmodel_emg.set(wind_data=wind_rose) +fmodel_emg_ti.set(wind_data=wind_rose) + +# Run the FLORIS model +fmodel_emg.run() +fmodel_emg_ti.run() + +# Get the power from the turbines +turbine_power_emg = fmodel_emg.get_turbine_powers() +turbine_power_emg_ti = fmodel_emg_ti.get_turbine_powers() + +# Currently the matrices have n_t * n_col columns, each corresponding to a turbine +# average the columns according to the column, this means averaging every n_t columns +turbine_power_emg = turbine_power_emg.reshape(turbine_power_emg.shape[0], -1, n_t) +turbine_power_emg = np.mean(turbine_power_emg, axis=2) +turbine_power_emg_ti = turbine_power_emg_ti.reshape(turbine_power_emg_ti.shape[0], -1, n_t) +turbine_power_emg_ti = np.mean(turbine_power_emg_ti, axis=2) + + +# Now determine the gridded wind speeds and directions +wd_grid, ws_grid = np.meshgrid(wind_directions, wind_speeds, indexing="ij") + +wd_flat = wd_grid.flatten() +ws_flat = ws_grid.flatten() + +# Now build up a dataframe +df_power_emg = pd.DataFrame( + data=turbine_power_emg, +) + +# Add additional columns +df_power_emg["wind_speed"] = ws_flat +df_power_emg["wind_direction"] = wd_flat +df_power_emg["model"] = "emg" + +# Repeat for the ti-enabled case +df_power_emg_ti = pd.DataFrame( + data=turbine_power_emg_ti, +) + +# Add additional columns +df_power_emg_ti["wind_speed"] = ws_flat +df_power_emg_ti["wind_direction"] = wd_flat +df_power_emg_ti["model"] = "emg_ti" + +# Concatenate the two dataframes +df = pd.concat([df_power_emg, df_power_emg_ti], axis=0) + +# Now make a figure comparing the two models +num_ws = len(wind_speeds) +fig, axarr = plt.subplots(num_ws, n_col - 1, figsize=(10, 10), sharex=True, sharey=True) + +for i, ws in enumerate(wind_speeds): + for j in range(n_col - 1): + ax = axarr[i, j] + # Get the data for the current wind speed + df_ws = df[df["wind_speed"] == ws] + + # Get the data for the current column + df_ws["ratio"] = df_ws[j + 1] / df_ws[0] + + # Now compare the ratios against wind direction for the emg and emg_ti models + df_ws_emg = df_ws[df_ws["model"] == "emg"] + df_ws_emg_ti = df_ws[df_ws["model"] == "emg_ti"] + + ax.plot(df_ws_emg["wind_direction"], df_ws_emg["ratio"], label="emg") + ax.plot(df_ws_emg_ti["wind_direction"], df_ws_emg_ti["ratio"], label="emg_ti") + + ax.set_xlabel("Wind direction") + ax.grid(True) + + if j == 0: + ax.set_ylabel(f"Power ratio for wind speed {ws}") + + if i == 0: + ax.set_title(f"Column {j + 1} of {n_col}") + + if i == 0 and j == 0: + ax.legend() + +plt.show() diff --git a/floris/__init__.py b/floris/__init__.py index 64c9e8c9a..0ac26a149 100644 --- a/floris/__init__.py +++ b/floris/__init__.py @@ -4,3 +4,18 @@ with open(Path(__file__).parent / "version.py") as _version_file: __version__ = _version_file.read().strip() + + +from .floris_model import FlorisModel +from .flow_visualization import ( + plot_rotor_values, + visualize_cut_plane, + visualize_quiver, +) +from .parallel_computing_interface import ParallelComputingInterface +from .uncertainty_interface import UncertaintyInterface +from .wind_data import ( + TimeSeries, + WindRose, + WindTIRose, +) diff --git a/floris/tools/convert_floris_input_v3_to_v4.py b/floris/convert_floris_input_v3_to_v4.py similarity index 100% rename from floris/tools/convert_floris_input_v3_to_v4.py rename to floris/convert_floris_input_v3_to_v4.py diff --git a/floris/tools/convert_turbine_v3_to_v4.py b/floris/convert_turbine_v3_to_v4.py similarity index 100% rename from floris/tools/convert_turbine_v3_to_v4.py rename to floris/convert_turbine_v3_to_v4.py diff --git a/floris/simulation/__init__.py b/floris/core/__init__.py similarity index 98% rename from floris/simulation/__init__.py rename to floris/core/__init__.py index 68da31838..e37f9c113 100644 --- a/floris/simulation/__init__.py +++ b/floris/core/__init__.py @@ -55,7 +55,7 @@ sequential_solver, turbopark_solver, ) -from .floris import Floris +from .core import Core # initialize the logger floris.logging_manager._setup_logger() diff --git a/floris/simulation/base.py b/floris/core/base.py similarity index 100% rename from floris/simulation/base.py rename to floris/core/base.py diff --git a/floris/simulation/floris.py b/floris/core/core.py similarity index 98% rename from floris/simulation/floris.py rename to floris/core/core.py index 5e1379dcd..a31583567 100644 --- a/floris/simulation/floris.py +++ b/floris/core/core.py @@ -9,7 +9,7 @@ from attrs import define, field from floris import logging_manager -from floris.simulation import ( +from floris.core import ( BaseClass, cc_solver, empirical_gauss_solver, @@ -38,7 +38,7 @@ @define -class Floris(BaseClass): +class Core(BaseClass): """ Top-level class that describes a Floris model and initializes the simulation. Use the :py:class:`~.simulation.farm.Farm` attribute to @@ -265,7 +265,7 @@ def solve_for_velocity_deficit_profiles( ) -> list[pd.DataFrame]: """ Extract velocity deficit profiles. See - :py:meth:`~floris.tools.floris_interface.FlorisInterface.sample_velocity_deficit_profiles` + :py:meth:`~floris.floris_model.FlorisModel.sample_velocity_deficit_profiles` for more details. """ @@ -336,7 +336,7 @@ def finalize(self): ## I/O @classmethod - def from_file(cls, input_file_path: str | Path) -> Floris: + def from_file(cls, input_file_path: str | Path) -> Core: """Creates a `Floris` instance from an input file. Must be filetype YAML. Args: @@ -348,7 +348,7 @@ def from_file(cls, input_file_path: str | Path) -> Floris: """ input_dict = load_yaml(Path(input_file_path).resolve()) check_input_file_for_v3_keys(input_dict) - return Floris.from_dict(input_dict) + return Core.from_dict(input_dict) def to_file(self, output_file_path: str) -> None: """Converts the `Floris` object to an input-ready YAML file at `output_file_path`. diff --git a/floris/simulation/farm.py b/floris/core/farm.py similarity index 98% rename from floris/simulation/farm.py rename to floris/core/farm.py index 678b47e3e..26cec1bec 100644 --- a/floris/simulation/farm.py +++ b/floris/core/farm.py @@ -15,13 +15,13 @@ from attrs import define, field from scipy.interpolate import interp1d -from floris.simulation import ( +from floris.core import ( BaseClass, State, Turbine, ) -from floris.simulation.rotor_velocity import compute_tilt_angles_for_floating_turbines_map -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.core.rotor_velocity import compute_tilt_angles_for_floating_turbines_map +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT from floris.type_dec import ( convert_to_path, floris_array_converter, diff --git a/floris/simulation/flow_field.py b/floris/core/flow_field.py similarity index 99% rename from floris/simulation/flow_field.py rename to floris/core/flow_field.py index ad9c54693..655f771a9 100644 --- a/floris/simulation/flow_field.py +++ b/floris/core/flow_field.py @@ -9,7 +9,7 @@ from scipy.spatial import ConvexHull from shapely.geometry import Polygon -from floris.simulation import ( +from floris.core import ( BaseClass, Grid, ) diff --git a/floris/simulation/grid.py b/floris/core/grid.py similarity index 99% rename from floris/simulation/grid.py rename to floris/core/grid.py index 926896821..3dc6280ae 100644 --- a/floris/simulation/grid.py +++ b/floris/core/grid.py @@ -8,7 +8,7 @@ import numpy as np from attrs import define, field -from floris.simulation import BaseClass +from floris.core import BaseClass from floris.type_dec import ( floris_array_converter, floris_float_type, diff --git a/floris/simulation/rotor_velocity.py b/floris/core/rotor_velocity.py similarity index 100% rename from floris/simulation/rotor_velocity.py rename to floris/core/rotor_velocity.py diff --git a/floris/simulation/solver.py b/floris/core/solver.py similarity index 99% rename from floris/simulation/solver.py rename to floris/core/solver.py index 011f41985..00abcc129 100644 --- a/floris/simulation/solver.py +++ b/floris/core/solver.py @@ -5,7 +5,7 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( axial_induction, Farm, FlowField, @@ -15,10 +15,10 @@ thrust_coefficient, TurbineGrid, ) -from floris.simulation.rotor_velocity import average_velocity -from floris.simulation.wake import WakeModelManager -from floris.simulation.wake_deflection.empirical_gauss import yaw_added_wake_mixing -from floris.simulation.wake_deflection.gauss import ( +from floris.core.rotor_velocity import average_velocity +from floris.core.wake import WakeModelManager +from floris.core.wake_deflection.empirical_gauss import yaw_added_wake_mixing +from floris.core.wake_deflection.gauss import ( calculate_transverse_velocity, wake_added_yaw, yaw_added_turbulence_mixing, diff --git a/floris/simulation/turbine/__init__.py b/floris/core/turbine/__init__.py similarity index 63% rename from floris/simulation/turbine/__init__.py rename to floris/core/turbine/__init__.py index 8f447dbee..5f361f463 100644 --- a/floris/simulation/turbine/__init__.py +++ b/floris/core/turbine/__init__.py @@ -1,5 +1,5 @@ -from floris.simulation.turbine.operation_models import ( +from floris.core.turbine.operation_models import ( CosineLossTurbine, MixedOperationTurbine, SimpleDeratingTurbine, diff --git a/floris/simulation/turbine/operation_models.py b/floris/core/turbine/operation_models.py similarity index 99% rename from floris/simulation/turbine/operation_models.py rename to floris/core/turbine/operation_models.py index 3d7a2b8e6..88f0f4fac 100644 --- a/floris/simulation/turbine/operation_models.py +++ b/floris/core/turbine/operation_models.py @@ -13,8 +13,8 @@ from attrs import define, field from scipy.interpolate import interp1d -from floris.simulation import BaseClass -from floris.simulation.rotor_velocity import ( +from floris.core import BaseClass +from floris.core.rotor_velocity import ( average_velocity, compute_tilt_angles_for_floating_turbines, rotor_velocity_tilt_correction, diff --git a/floris/simulation/turbine/turbine.py b/floris/core/turbine/turbine.py similarity index 99% rename from floris/simulation/turbine/turbine.py rename to floris/core/turbine/turbine.py index 191072ce6..dbc588093 100644 --- a/floris/simulation/turbine/turbine.py +++ b/floris/core/turbine/turbine.py @@ -11,8 +11,8 @@ from attrs import define, field from scipy.interpolate import interp1d -from floris.simulation import BaseClass -from floris.simulation.turbine import ( +from floris.core import BaseClass +from floris.core.turbine import ( CosineLossTurbine, MixedOperationTurbine, SimpleDeratingTurbine, diff --git a/floris/simulation/wake.py b/floris/core/wake.py similarity index 95% rename from floris/simulation/wake.py rename to floris/core/wake.py index 28560151a..2f9907c99 100644 --- a/floris/simulation/wake.py +++ b/floris/core/wake.py @@ -2,24 +2,24 @@ import attrs from attrs import define, field -from floris.simulation import BaseClass, BaseModel -from floris.simulation.wake_combination import ( +from floris.core import BaseClass, BaseModel +from floris.core.wake_combination import ( FLS, MAX, SOSFS, ) -from floris.simulation.wake_deflection import ( +from floris.core.wake_deflection import ( EmpiricalGaussVelocityDeflection, GaussVelocityDeflection, JimenezVelocityDeflection, NoneVelocityDeflection, ) -from floris.simulation.wake_turbulence import ( +from floris.core.wake_turbulence import ( CrespoHernandez, NoneWakeTurbulence, WakeInducedMixing, ) -from floris.simulation.wake_velocity import ( +from floris.core.wake_velocity import ( CumulativeGaussCurlVelocityDeficit, EmpiricalGaussVelocityDeficit, GaussVelocityDeficit, diff --git a/floris/core/wake_combination/__init__.py b/floris/core/wake_combination/__init__.py new file mode 100644 index 000000000..246aab65c --- /dev/null +++ b/floris/core/wake_combination/__init__.py @@ -0,0 +1,4 @@ + +from floris.core.wake_combination.fls import FLS +from floris.core.wake_combination.max import MAX +from floris.core.wake_combination.sosfs import SOSFS diff --git a/floris/simulation/wake_combination/fls.py b/floris/core/wake_combination/fls.py similarity index 95% rename from floris/simulation/wake_combination/fls.py rename to floris/core/wake_combination/fls.py index fa2d88326..42e68045f 100644 --- a/floris/simulation/wake_combination/fls.py +++ b/floris/core/wake_combination/fls.py @@ -2,7 +2,7 @@ import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_combination/max.py b/floris/core/wake_combination/max.py similarity index 96% rename from floris/simulation/wake_combination/max.py rename to floris/core/wake_combination/max.py index f4beda1c8..0898cc842 100644 --- a/floris/simulation/wake_combination/max.py +++ b/floris/core/wake_combination/max.py @@ -2,7 +2,7 @@ import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_combination/sosfs.py b/floris/core/wake_combination/sosfs.py similarity index 95% rename from floris/simulation/wake_combination/sosfs.py rename to floris/core/wake_combination/sosfs.py index 6598faf2b..c277e21bb 100644 --- a/floris/simulation/wake_combination/sosfs.py +++ b/floris/core/wake_combination/sosfs.py @@ -2,7 +2,7 @@ import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/core/wake_deflection/__init__.py b/floris/core/wake_deflection/__init__.py new file mode 100644 index 000000000..ba5e63788 --- /dev/null +++ b/floris/core/wake_deflection/__init__.py @@ -0,0 +1,5 @@ + +from floris.core.wake_deflection.empirical_gauss import EmpiricalGaussVelocityDeflection +from floris.core.wake_deflection.gauss import GaussVelocityDeflection +from floris.core.wake_deflection.jimenez import JimenezVelocityDeflection +from floris.core.wake_deflection.none import NoneVelocityDeflection diff --git a/floris/simulation/wake_deflection/empirical_gauss.py b/floris/core/wake_deflection/empirical_gauss.py similarity index 99% rename from floris/simulation/wake_deflection/empirical_gauss.py rename to floris/core/wake_deflection/empirical_gauss.py index 85681544c..00a506b3c 100644 --- a/floris/simulation/wake_deflection/empirical_gauss.py +++ b/floris/core/wake_deflection/empirical_gauss.py @@ -4,7 +4,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_deflection/gauss.py b/floris/core/wake_deflection/gauss.py similarity index 99% rename from floris/simulation/wake_deflection/gauss.py rename to floris/core/wake_deflection/gauss.py index fc1cedfc4..e19fd147b 100644 --- a/floris/simulation/wake_deflection/gauss.py +++ b/floris/core/wake_deflection/gauss.py @@ -12,7 +12,7 @@ ) from numpy import pi -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_deflection/jimenez.py b/floris/core/wake_deflection/jimenez.py similarity index 93% rename from floris/simulation/wake_deflection/jimenez.py rename to floris/core/wake_deflection/jimenez.py index 6f0a8ccf6..daca6e9c5 100644 --- a/floris/simulation/wake_deflection/jimenez.py +++ b/floris/core/wake_deflection/jimenez.py @@ -5,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -64,13 +64,13 @@ def function( y_locations (np.array): spanwise locations in wake z_locations (np.array): vertical locations in wake (not used in Jiménez) - turbine (:py:class:`floris.simulation.turbine.Turbine`): + turbine (:py:class:`floris.core.turbine.Turbine`): Turbine object coord - (:py:meth:`floris.simulation.turbine_map.TurbineMap.coords`): + (:py:meth:`floris.core.turbine_map.TurbineMap.coords`): Spatial coordinates of wind turbine. flow_field - (:py:class:`floris.simulation.flow_field.FlowField`): + (:py:class:`floris.core.flow_field.FlowField`): Flow field object. Returns: diff --git a/floris/simulation/wake_deflection/none.py b/floris/core/wake_deflection/none.py similarity index 97% rename from floris/simulation/wake_deflection/none.py rename to floris/core/wake_deflection/none.py index 44e466651..b428c8af9 100644 --- a/floris/simulation/wake_deflection/none.py +++ b/floris/core/wake_deflection/none.py @@ -4,7 +4,7 @@ import numpy as np from attrs import define -from floris.simulation import ( +from floris.core import ( BaseModel, FlowField, Grid, diff --git a/floris/core/wake_turbulence/__init__.py b/floris/core/wake_turbulence/__init__.py new file mode 100644 index 000000000..8bec72939 --- /dev/null +++ b/floris/core/wake_turbulence/__init__.py @@ -0,0 +1,4 @@ + +from floris.core.wake_turbulence.crespo_hernandez import CrespoHernandez +from floris.core.wake_turbulence.none import NoneWakeTurbulence +from floris.core.wake_turbulence.wake_induced_mixing import WakeInducedMixing diff --git a/floris/simulation/wake_turbulence/crespo_hernandez.py b/floris/core/wake_turbulence/crespo_hernandez.py similarity index 98% rename from floris/simulation/wake_turbulence/crespo_hernandez.py rename to floris/core/wake_turbulence/crespo_hernandez.py index 09d045986..b5c623fe0 100644 --- a/floris/simulation/wake_turbulence/crespo_hernandez.py +++ b/floris/core/wake_turbulence/crespo_hernandez.py @@ -5,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_turbulence/none.py b/floris/core/wake_turbulence/none.py similarity index 95% rename from floris/simulation/wake_turbulence/none.py rename to floris/core/wake_turbulence/none.py index 3975c2581..146ca970b 100644 --- a/floris/simulation/wake_turbulence/none.py +++ b/floris/core/wake_turbulence/none.py @@ -4,7 +4,7 @@ import numpy as np from attrs import define, field -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_turbulence/wake_induced_mixing.py b/floris/core/wake_turbulence/wake_induced_mixing.py similarity index 98% rename from floris/simulation/wake_turbulence/wake_induced_mixing.py rename to floris/core/wake_turbulence/wake_induced_mixing.py index f39e6a8a6..64306ff75 100644 --- a/floris/simulation/wake_turbulence/wake_induced_mixing.py +++ b/floris/core/wake_turbulence/wake_induced_mixing.py @@ -4,7 +4,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/core/wake_velocity/__init__.py b/floris/core/wake_velocity/__init__.py new file mode 100644 index 000000000..dc1342f8a --- /dev/null +++ b/floris/core/wake_velocity/__init__.py @@ -0,0 +1,7 @@ + +from floris.core.wake_velocity.cumulative_gauss_curl import CumulativeGaussCurlVelocityDeficit +from floris.core.wake_velocity.empirical_gauss import EmpiricalGaussVelocityDeficit +from floris.core.wake_velocity.gauss import GaussVelocityDeficit +from floris.core.wake_velocity.jensen import JensenVelocityDeficit +from floris.core.wake_velocity.none import NoneVelocityDeficit +from floris.core.wake_velocity.turbopark import TurbOParkVelocityDeficit diff --git a/floris/simulation/wake_velocity/cumulative_gauss_curl.py b/floris/core/wake_velocity/cumulative_gauss_curl.py similarity index 99% rename from floris/simulation/wake_velocity/cumulative_gauss_curl.py rename to floris/core/wake_velocity/cumulative_gauss_curl.py index 902b085b5..86d8c982e 100644 --- a/floris/simulation/wake_velocity/cumulative_gauss_curl.py +++ b/floris/core/wake_velocity/cumulative_gauss_curl.py @@ -5,7 +5,7 @@ from attrs import define, field from scipy.special import gamma -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_velocity/empirical_gauss.py b/floris/core/wake_velocity/empirical_gauss.py similarity index 99% rename from floris/simulation/wake_velocity/empirical_gauss.py rename to floris/core/wake_velocity/empirical_gauss.py index cfeb261fb..722771012 100644 --- a/floris/simulation/wake_velocity/empirical_gauss.py +++ b/floris/core/wake_velocity/empirical_gauss.py @@ -5,14 +5,14 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, Grid, Turbine, ) -from floris.simulation.wake_velocity.gauss import gaussian_function +from floris.core.wake_velocity.gauss import gaussian_function from floris.utilities import ( cosd, sind, diff --git a/floris/simulation/wake_velocity/gauss.py b/floris/core/wake_velocity/gauss.py similarity index 99% rename from floris/simulation/wake_velocity/gauss.py rename to floris/core/wake_velocity/gauss.py index 4cf5cbdf9..5c73786ae 100644 --- a/floris/simulation/wake_velocity/gauss.py +++ b/floris/core/wake_velocity/gauss.py @@ -5,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_velocity/jensen.py b/floris/core/wake_velocity/jensen.py similarity index 99% rename from floris/simulation/wake_velocity/jensen.py rename to floris/core/wake_velocity/jensen.py index f84461502..7d6b09c31 100644 --- a/floris/simulation/wake_velocity/jensen.py +++ b/floris/core/wake_velocity/jensen.py @@ -9,7 +9,7 @@ fields, ) -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_velocity/none.py b/floris/core/wake_velocity/none.py similarity index 97% rename from floris/simulation/wake_velocity/none.py rename to floris/core/wake_velocity/none.py index 37b4e09bc..af1ea448a 100644 --- a/floris/simulation/wake_velocity/none.py +++ b/floris/core/wake_velocity/none.py @@ -4,7 +4,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, FlowField, Grid, diff --git a/floris/simulation/wake_velocity/turbopark.py b/floris/core/wake_velocity/turbopark.py similarity index 99% rename from floris/simulation/wake_velocity/turbopark.py rename to floris/core/wake_velocity/turbopark.py index 33071f9a1..63ad6e06c 100644 --- a/floris/simulation/wake_velocity/turbopark.py +++ b/floris/core/wake_velocity/turbopark.py @@ -9,7 +9,7 @@ from scipy import integrate from scipy.interpolate import RegularGridInterpolator -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_velocity/turbopark_lookup_table.mat b/floris/core/wake_velocity/turbopark_lookup_table.mat similarity index 100% rename from floris/simulation/wake_velocity/turbopark_lookup_table.mat rename to floris/core/wake_velocity/turbopark_lookup_table.mat diff --git a/floris/tools/cut_plane.py b/floris/cut_plane.py similarity index 99% rename from floris/tools/cut_plane.py rename to floris/cut_plane.py index 64c24458b..10c573353 100644 --- a/floris/tools/cut_plane.py +++ b/floris/cut_plane.py @@ -338,7 +338,7 @@ def calculate_wind_speed(cross_plane, x1_loc, x2_loc, R): Calculate effective wind speed within specified range of a point. Args: - cross_plane (:py:class:`floris.tools.cut_plane.CrossPlane`): + cross_plane (:py:class:`floris.cut_plane.CrossPlane`): plane of data. x1_loc (float): x1-coordinate of point of interest. x2_loc (float): x2-coordinate of point of interest. @@ -377,7 +377,7 @@ def calculate_power( Calculate maximum power available in a given cross plane. Args: - cross_plane (:py:class:`floris.tools.cut_plane.CrossPlane`): + cross_plane (:py:class:`floris.cut_plane.CrossPlane`): plane of data. x1_loc (float): x1-coordinate of point of interest. x2_loc (float): x2-coordinate of point of interest. diff --git a/floris/tools/floris_interface.py b/floris/floris_model.py similarity index 84% rename from floris/tools/floris_interface.py rename to floris/floris_model.py index 5c67219ee..58598a3b0 100644 --- a/floris/tools/floris_interface.py +++ b/floris/floris_model.py @@ -7,30 +7,30 @@ import numpy as np import pandas as pd -from floris.logging_manager import LoggingManager -from floris.simulation import Floris, State -from floris.simulation.rotor_velocity import average_velocity -from floris.simulation.turbine.operation_models import ( +from floris.core import Core, State +from floris.core.rotor_velocity import average_velocity +from floris.core.turbine.operation_models import ( POWER_SETPOINT_DEFAULT, POWER_SETPOINT_DISABLED, ) -from floris.simulation.turbine.turbine import ( +from floris.core.turbine.turbine import ( axial_induction, power, thrust_coefficient, ) -from floris.tools.cut_plane import CutPlane -from floris.tools.wind_data import WindDataBase +from floris.cut_plane import CutPlane +from floris.logging_manager import LoggingManager from floris.type_dec import ( floris_array_converter, NDArrayBool, NDArrayFloat, ) +from floris.wind_data import WindDataBase -class FlorisInterface(LoggingManager): +class FlorisModel(LoggingManager): """ - FlorisInterface provides a high-level user interface to many of the + FlorisModel provides a high-level user interface to many of the underlying methods within the FLORIS framework. It is meant to act as a single entry-point for the majority of users, simplifying the calls to methods on objects within FLORIS. @@ -42,7 +42,7 @@ class FlorisInterface(LoggingManager): - **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.floris.Floris` for more details. + - **logging**: See `floris.simulation.core.Core` for more details. """ def __init__(self, configuration: dict | str | Path): @@ -50,31 +50,31 @@ def __init__(self, configuration: dict | str | Path): if isinstance(self.configuration, (str, Path)): try: - self.floris = Floris.from_file(self.configuration) + self.core = Core.from_file(self.configuration) except FileNotFoundError: # If the file cannot be found, then attempt the configuration path relative to the - # file location from which FlorisInterface was attempted to be run. If successful, + # file location from which FlorisModel was attempted to be run. If successful, # update self.configuration to an absolute, working file path and name. base_fn = Path(inspect.stack()[-1].filename).resolve().parent config = (base_fn / self.configuration).resolve() - self.floris = Floris.from_file(config) + self.core = Core.from_file(config) self.configuration = config elif isinstance(self.configuration, dict): - self.floris = Floris.from_dict(self.configuration) + self.core = Core.from_dict(self.configuration) else: raise TypeError("The Floris `configuration` must be of type 'dict', 'str', or 'Path'.") # If ref height is -1, assign the hub height - if np.abs(self.floris.flow_field.reference_wind_height + 1.0) < 1.0e-6: + if np.abs(self.core.flow_field.reference_wind_height + 1.0) < 1.0e-6: self.assign_hub_height_to_ref_height() # Make a check on reference height and provide a helpful warning - unique_heights = np.unique(np.round(self.floris.farm.hub_heights, decimals=6)) + unique_heights = np.unique(np.round(self.core.farm.hub_heights, decimals=6)) if (( len(unique_heights) == 1) and - (np.abs(self.floris.flow_field.reference_wind_height - unique_heights[0]) > 1.0e-6 + (np.abs(self.core.flow_field.reference_wind_height - unique_heights[0]) > 1.0e-6 )): err_msg = ( "The only unique hub-height is not the equal to the specified reference " @@ -84,10 +84,10 @@ def __init__(self, configuration: dict | str | Path): self.logger.warning(err_msg, stack_info=True) # Check the turbine_grid_points is reasonable - if self.floris.solver["type"] == "turbine_grid": - if self.floris.solver["turbine_grid_points"] > 3: + if self.core.solver["type"] == "turbine_grid": + if self.core.solver["turbine_grid_points"] > 3: self.logger.error( - f"turbine_grid_points value is {self.floris.solver['turbine_grid_points']} " + f"turbine_grid_points value is {self.core.solver['turbine_grid_points']} " "which is larger than the recommended value of less than or equal to 3. " "High amounts of turbine grid points reduce the computational performance " "but have a small change on accuracy." @@ -97,7 +97,7 @@ def __init__(self, configuration: dict | str | Path): def assign_hub_height_to_ref_height(self): # Confirm can do this operation - unique_heights = np.unique(self.floris.farm.hub_heights) + unique_heights = np.unique(self.core.farm.hub_heights) if len(unique_heights) > 1: raise ValueError( "To assign hub heights to reference height, can not have more than one " @@ -105,11 +105,11 @@ def assign_hub_height_to_ref_height(self): f"Current length is {unique_heights}." ) - self.floris.flow_field.reference_wind_height = unique_heights[0] + self.core.flow_field.reference_wind_height = unique_heights[0] def copy(self): - """Create an independent copy of the current FlorisInterface object""" - return FlorisInterface(self.floris.as_dict()) + """Create an independent copy of the current FlorisModel object""" + return FlorisModel(self.core.as_dict()) def set( self, @@ -165,8 +165,8 @@ def set( and the power setpoint at that position is set to 0. Defaults to None. """ # Initialize a new Floris object after saving the setpoints - _yaw_angles = self.floris.farm.yaw_angles - _power_setpoints = self.floris.farm.power_setpoints + _yaw_angles = self.core.farm.yaw_angles + _power_setpoints = self.core.farm.power_setpoints self._reinitialize( wind_speeds=wind_speeds, wind_directions=wind_directions, @@ -187,12 +187,12 @@ def set( # If the yaw angles or power setpoints are not the default, set them back to the # previous setting if not (_yaw_angles == 0).all(): - self.floris.farm.set_yaw_angles(_yaw_angles) + self.core.farm.set_yaw_angles(_yaw_angles) if not ( (_power_setpoints == POWER_SETPOINT_DEFAULT) | (_power_setpoints == POWER_SETPOINT_DISABLED) ).all(): - self.floris.farm.set_power_setpoints(_power_setpoints) + self.core.farm.set_power_setpoints(_power_setpoints) # Set the operation self._set_operation( @@ -252,7 +252,7 @@ def _reinitialize( wind_data (type[WindDataBase] | None, optional): Wind data. Defaults to None. """ # Export the floris object recursively as a dictionary - floris_dict = self.floris.as_dict() + floris_dict = self.core.as_dict() flow_field_dict = floris_dict["flow_field"] farm_dict = floris_dict["farm"] @@ -316,7 +316,7 @@ def _reinitialize( floris_dict["farm"] = farm_dict # Create a new instance of floris and attach to self - self.floris = Floris.from_dict(floris_dict) + self.core = Core.from_dict(floris_dict) def _set_operation( self, @@ -337,7 +337,7 @@ def _set_operation( """ # Add operating conditions to the floris object if yaw_angles is not None: - self.floris.farm.set_yaw_angles(yaw_angles) + self.core.farm.set_yaw_angles(yaw_angles) if power_setpoints is not None: power_setpoints = np.array(power_setpoints) @@ -348,7 +348,7 @@ def _set_operation( ] = POWER_SETPOINT_DEFAULT power_setpoints = floris_array_converter(power_setpoints) - self.floris.farm.set_power_setpoints(power_setpoints) + self.core.farm.set_power_setpoints(power_setpoints) # Check for turbines to disable if disable_turbines is not None: @@ -357,25 +357,25 @@ def _set_operation( disable_turbines = np.array(disable_turbines) # Must have first dimension = n_findex - if disable_turbines.shape[0] != self.floris.flow_field.n_findex: + if disable_turbines.shape[0] != self.core.flow_field.n_findex: raise ValueError( f"disable_turbines has a size of {disable_turbines.shape[0]} " f"in the 0th dimension, must be equal to " - f"n_findex={self.floris.flow_field.n_findex}" + f"n_findex={self.core.flow_field.n_findex}" ) # Must have first dimension = n_turbines - if disable_turbines.shape[1] != self.floris.farm.n_turbines: + if disable_turbines.shape[1] != self.core.farm.n_turbines: raise ValueError( f"disable_turbines has a size of {disable_turbines.shape[1]} " f"in the 1th dimension, must be equal to " - f"n_turbines={self.floris.farm.n_turbines}" + f"n_turbines={self.core.farm.n_turbines}" ) # Set power setpoints to small value (non zero to avoid numerical issues) and # yaw_angles to 0 in all locations where disable_turbines is True - self.floris.farm.yaw_angles[disable_turbines] = 0.0 - self.floris.farm.power_setpoints[disable_turbines] = POWER_SETPOINT_DISABLED + self.core.farm.yaw_angles[disable_turbines] = 0.0 + self.core.farm.power_setpoints[disable_turbines] = POWER_SETPOINT_DISABLED def run(self) -> None: """ @@ -383,10 +383,10 @@ def run(self) -> None: """ # Initialize solution space - self.floris.initialize_domain() + self.core.initialize_domain() # Perform the wake calculations - self.floris.steady_state_atmospheric_condition() + self.core.steady_state_atmospheric_condition() def run_no_wake(self) -> None: """ @@ -396,10 +396,10 @@ def run_no_wake(self) -> None: """ # Initialize solution space - self.floris.initialize_domain() + self.core.initialize_domain() # Finalize values to user-supplied order - self.floris.finalize() + self.core.finalize() def get_plane_of_points( self, @@ -408,7 +408,7 @@ def get_plane_of_points( ): """ Calculates velocity values through the - :py:meth:`FlorisInterface.calculate_wake` method at points in plane + :py:meth:`FlorisModel.calculate_wake` method at points in plane specified by inputs. Args: @@ -422,16 +422,16 @@ def get_plane_of_points( """ # Get results vectors if normal_vector == "z": - x_flat = self.floris.grid.x_sorted_inertial_frame[0].flatten() - y_flat = self.floris.grid.y_sorted_inertial_frame[0].flatten() - z_flat = self.floris.grid.z_sorted_inertial_frame[0].flatten() + x_flat = self.core.grid.x_sorted_inertial_frame[0].flatten() + y_flat = self.core.grid.y_sorted_inertial_frame[0].flatten() + z_flat = self.core.grid.z_sorted_inertial_frame[0].flatten() else: - x_flat = self.floris.grid.x_sorted[0].flatten() - y_flat = self.floris.grid.y_sorted[0].flatten() - z_flat = self.floris.grid.z_sorted[0].flatten() - u_flat = self.floris.flow_field.u_sorted[0].flatten() - v_flat = self.floris.flow_field.v_sorted[0].flatten() - w_flat = self.floris.flow_field.w_sorted[0].flatten() + x_flat = self.core.grid.x_sorted[0].flatten() + y_flat = self.core.grid.y_sorted[0].flatten() + z_flat = self.core.grid.z_sorted[0].flatten() + u_flat = self.core.flow_field.u_sorted[0].flatten() + v_flat = self.core.flow_field.v_sorted[0].flatten() + w_flat = self.core.flow_field.w_sorted[0].flatten() # Create a df of these if normal_vector == "z": @@ -525,13 +525,13 @@ def calculate_horizontal_plane( """ # TODO update docstring if wd is None: - wd = self.floris.flow_field.wind_directions + wd = self.core.flow_field.wind_directions if ws is None: - ws = self.floris.flow_field.wind_speeds + ws = self.core.flow_field.wind_speeds self.check_wind_condition_for_viz(wd=wd, ws=ws) # Store the current state for reinitialization - floris_dict = self.floris.as_dict() + floris_dict = self.core.as_dict() # Set the solver to a flow field planar grid solver_settings = { "type": "flow_field_planar_grid", @@ -550,7 +550,7 @@ def calculate_horizontal_plane( ) # Calculate wake - self.floris.solve_for_viz() + self.core.solve_for_viz() # Get the points of data in a dataframe # TODO this just seems to be flattening and storing the data in a df; is this necessary? @@ -563,13 +563,13 @@ def calculate_horizontal_plane( # Compute the cutplane horizontal_plane = CutPlane( df, - self.floris.grid.grid_resolution[0], - self.floris.grid.grid_resolution[1], + self.core.grid.grid_resolution[0], + self.core.grid.grid_resolution[1], "z", ) - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) + # Reset the fmodel object back to the turbine grid configuration + self.core = Core.from_dict(floris_dict) # Run the simulation again for futher postprocessing (i.e. now we can get farm power) self.run() @@ -611,13 +611,13 @@ def calculate_cross_plane( """ # TODO update docstring if wd is None: - wd = self.floris.flow_field.wind_directions + wd = self.core.flow_field.wind_directions if ws is None: - ws = self.floris.flow_field.wind_speeds + ws = self.core.flow_field.wind_speeds self.check_wind_condition_for_viz(wd=wd, ws=ws) # Store the current state for reinitialization - floris_dict = self.floris.as_dict() + floris_dict = self.core.as_dict() # Set the solver to a flow field planar grid solver_settings = { @@ -637,7 +637,7 @@ def calculate_cross_plane( ) # Calculate wake - self.floris.solve_for_viz() + self.core.solve_for_viz() # Get the points of data in a dataframe # TODO this just seems to be flattening and storing the data in a df; is this necessary? @@ -650,8 +650,8 @@ def calculate_cross_plane( # Compute the cutplane cross_plane = CutPlane(df, y_resolution, z_resolution, "x") - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) + # Reset the fmodel object back to the turbine grid configuration + self.core = Core.from_dict(floris_dict) # Run the simulation again for futher postprocessing (i.e. now we can get farm power) self.run() @@ -705,13 +705,13 @@ def calculate_y_plane( """ # TODO update docstring if wd is None: - wd = self.floris.flow_field.wind_directions + wd = self.core.flow_field.wind_directions if ws is None: - ws = self.floris.flow_field.wind_speeds + ws = self.core.flow_field.wind_speeds self.check_wind_condition_for_viz(wd=wd, ws=ws) # Store the current state for reinitialization - floris_dict = self.floris.as_dict() + floris_dict = self.core.as_dict() # Set the solver to a flow field planar grid solver_settings = { @@ -731,7 +731,7 @@ def calculate_y_plane( ) # Calculate wake - self.floris.solve_for_viz() + self.core.solve_for_viz() # Get the points of data in a dataframe # TODO this just seems to be flattening and storing the data in a df; is this necessary? @@ -744,8 +744,8 @@ def calculate_y_plane( # Compute the cutplane y_plane = CutPlane(df, x_resolution, z_resolution, "y") - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) + # Reset the fmodel object back to the turbine grid configuration + self.core = Core.from_dict(floris_dict) # Run the simulation again for futher postprocessing (i.e. now we can get farm power) self.run() @@ -773,77 +773,77 @@ def get_turbine_powers(self) -> NDArrayFloat: """ # Confirm calculate wake has been run - if self.floris.state is not State.USED: + if self.core.state is not State.USED: raise RuntimeError( - "Can't run function `FlorisInterface.get_turbine_powers` without " - "first running `FlorisInterface.run`." + "Can't run function `FlorisModel.get_turbine_powers` without " + "first running `FlorisModel.run`." ) # Check for negative velocities, which could indicate bad model # parameters or turbines very closely spaced. - if (self.floris.flow_field.u < 0.0).any(): + if (self.core.flow_field.u < 0.0).any(): self.logger.warning("Some velocities at the rotor are negative.") turbine_powers = power( - velocities=self.floris.flow_field.u, - air_density=self.floris.flow_field.air_density, - power_functions=self.floris.farm.turbine_power_functions, - yaw_angles=self.floris.farm.yaw_angles, - tilt_angles=self.floris.farm.tilt_angles, - power_setpoints=self.floris.farm.power_setpoints, - tilt_interps=self.floris.farm.turbine_tilt_interps, - turbine_type_map=self.floris.farm.turbine_type_map, - turbine_power_thrust_tables=self.floris.farm.turbine_power_thrust_tables, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - multidim_condition=self.floris.flow_field.multidim_conditions, + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + power_functions=self.core.farm.turbine_power_functions, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + tilt_interps=self.core.farm.turbine_tilt_interps, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + multidim_condition=self.core.flow_field.multidim_conditions, ) return turbine_powers def get_turbine_thrust_coefficients(self) -> NDArrayFloat: turbine_thrust_coefficients = thrust_coefficient( - velocities=self.floris.flow_field.u, - air_density=self.floris.flow_field.air_density, - yaw_angles=self.floris.farm.yaw_angles, - tilt_angles=self.floris.farm.tilt_angles, - power_setpoints=self.floris.farm.power_setpoints, - thrust_coefficient_functions=self.floris.farm.turbine_thrust_coefficient_functions, - tilt_interps=self.floris.farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - turbine_type_map=self.floris.farm.turbine_type_map, - turbine_power_thrust_tables=self.floris.farm.turbine_power_thrust_tables, - average_method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights, - multidim_condition=self.floris.flow_field.multidim_conditions, + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + thrust_coefficient_functions=self.core.farm.turbine_thrust_coefficient_functions, + tilt_interps=self.core.farm.turbine_tilt_interps, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + average_method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, + multidim_condition=self.core.flow_field.multidim_conditions, ) return turbine_thrust_coefficients def get_turbine_ais(self) -> NDArrayFloat: turbine_ais = axial_induction( - velocities=self.floris.flow_field.u, - air_density=self.floris.flow_field.air_density, - yaw_angles=self.floris.farm.yaw_angles, - tilt_angles=self.floris.farm.tilt_angles, - power_setpoints=self.floris.farm.power_setpoints, - axial_induction_functions=self.floris.farm.turbine_axial_induction_functions, - tilt_interps=self.floris.farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - turbine_type_map=self.floris.farm.turbine_type_map, - turbine_power_thrust_tables=self.floris.farm.turbine_power_thrust_tables, - average_method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights, - multidim_condition=self.floris.flow_field.multidim_conditions, + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + axial_induction_functions=self.core.farm.turbine_axial_induction_functions, + tilt_interps=self.core.farm.turbine_tilt_interps, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + average_method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, + multidim_condition=self.core.flow_field.multidim_conditions, ) return turbine_ais @property def turbine_average_velocities(self) -> NDArrayFloat: return average_velocity( - velocities=self.floris.flow_field.u, - method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights, + velocities=self.core.flow_field.u, + method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, ) def get_turbine_TIs(self) -> NDArrayFloat: - return self.floris.flow_field.turbulence_intensity_field + return self.core.flow_field.turbulence_intensity_field def get_farm_power( self, @@ -882,29 +882,29 @@ def get_farm_power( # the model yet # TODO: Turbines need a switch for using turbulence correction # TODO: Uncomment out the following two lines once the above are resolved - # for turbine in self.floris.farm.turbines: + # for turbine in self.core.farm.turbines: # turbine.use_turbulence_correction = use_turbulence_correction # Confirm calculate wake has been run - if self.floris.state is not State.USED: + if self.core.state is not State.USED: raise RuntimeError( - "Can't run function `FlorisInterface.get_turbine_powers` without " - "first running `FlorisInterface.calculate_wake`." + "Can't run function `FlorisModel.get_turbine_powers` without " + "first running `FlorisModel.calculate_wake`." ) if turbine_weights is None: # Default to equal weighing of all turbines when turbine_weights is None turbine_weights = np.ones( ( - self.floris.flow_field.n_findex, - self.floris.farm.n_turbines, + self.core.flow_field.n_findex, + self.core.farm.n_turbines, ) ) elif len(np.shape(turbine_weights)) == 1: # Deal with situation when 1D array is provided turbine_weights = np.tile( turbine_weights, - (self.floris.flow_field.n_findex, 1), + (self.core.flow_field.n_findex, 1), ) # Calculate all turbine powers and apply weights @@ -966,7 +966,7 @@ def get_farm_AEP( """ # Verify dimensions of the variable "freq" - if np.shape(freq)[0] != self.floris.flow_field.n_findex: + if np.shape(freq)[0] != self.core.flow_field.n_findex: raise UserWarning( "'freq' should be a one-dimensional array with dimensions (n_findex). " f"Given shape is {np.shape(freq)}" @@ -980,12 +980,10 @@ def get_farm_AEP( # Copy the full wind speed array from the floris object and initialize # the the farm_power variable as an empty array. - wind_speeds = np.array(self.floris.flow_field.wind_speeds, copy=True) - wind_directions = np.array(self.floris.flow_field.wind_directions, copy=True) - turbulence_intensities = np.array( - self.floris.flow_field.turbulence_intensities, copy=True - ) - farm_power = np.zeros(self.floris.flow_field.n_findex) + wind_speeds = np.array(self.core.flow_field.wind_speeds, copy=True) + wind_directions = np.array(self.core.flow_field.wind_directions, copy=True) + turbulence_intensities = np.array(self.core.flow_field.turbulence_intensities, copy=True) + farm_power = np.zeros(self.core.flow_field.n_findex) # Determine which wind speeds we must evaluate conditions_to_evaluate = wind_speeds >= cut_in_wind_speed @@ -1072,7 +1070,7 @@ def get_farm_AEP_with_wind_data( """ # Verify the wind_data object matches FLORIS' initialization - if wind_data.n_findex != self.floris.flow_field.n_findex: + if wind_data.n_findex != self.core.flow_field.n_findex: raise ValueError("WindData object and floris do not have same findex") # Get freq directly from wind_data @@ -1104,7 +1102,7 @@ def sample_flow_at_points(self, x: NDArrayFloat, y: NDArrayFloat, z: NDArrayFloa if not len(x) == len(y) == len(z): raise ValueError("x, y, and z must be the same size") - return self.floris.solve_for_points(x, y, z) + return self.core.solve_for_points(x, y, z) def sample_velocity_deficit_profiles( self, @@ -1155,7 +1153,7 @@ def sample_velocity_deficit_profiles( raise ValueError("`direction` must be either `cross-stream` or `vertical`.") if ref_rotor_diameter is None: - unique_rotor_diameters = np.unique(self.floris.farm.rotor_diameters) + unique_rotor_diameters = np.unique(self.core.farm.rotor_diameters) if len(unique_rotor_diameters) == 1: ref_rotor_diameter = unique_rotor_diameters[0] else: @@ -1172,9 +1170,9 @@ def sample_velocity_deficit_profiles( if profile_range is None: profile_range = ref_rotor_diameter * np.array([-2, 2]) - wind_directions_copy = np.array(self.floris.flow_field.wind_directions, copy=True) - wind_speeds_copy = np.array(self.floris.flow_field.wind_speeds, copy=True) - wind_shear_copy = self.floris.flow_field.wind_shear + wind_directions_copy = np.array(self.core.flow_field.wind_directions, copy=True) + wind_speeds_copy = np.array(self.core.flow_field.wind_speeds, copy=True) + wind_shear_copy = self.core.flow_field.wind_shear if wind_direction is None: if len(wind_directions_copy) == 1: @@ -1202,7 +1200,7 @@ def sample_velocity_deficit_profiles( ) if reference_height is None: - reference_height = self.floris.flow_field.reference_wind_height + reference_height = self.core.flow_field.reference_wind_height self.set( wind_directions=[wind_direction], @@ -1210,7 +1208,7 @@ def sample_velocity_deficit_profiles( wind_shear=0.0, ) - velocity_deficit_profiles = self.floris.solve_for_velocity_deficit_profiles( + velocity_deficit_profiles = self.core.solve_for_velocity_deficit_profiles( direction, downstream_dists, profile_range, @@ -1238,7 +1236,7 @@ def layout_x(self): Returns: np.array: Wind turbine x-coordinate. """ - return self.floris.farm.layout_x + return self.core.farm.layout_x @property def layout_y(self): @@ -1248,7 +1246,7 @@ def layout_y(self): Returns: np.array: Wind turbine y-coordinate. """ - return self.floris.farm.layout_y + return self.core.farm.layout_y def get_turbine_layout(self, z=False): """ @@ -1262,7 +1260,7 @@ def get_turbine_layout(self, z=False): np.array: lists of x, y, and (optionally) z coordinates of each turbine """ - xcoords, ycoords, zcoords = self.floris.farm.coordinates.T + xcoords, ycoords, zcoords = self.core.farm.coordinates.T if z: return xcoords, ycoords, zcoords else: diff --git a/floris/tools/flow_visualization.py b/floris/flow_visualization.py similarity index 93% rename from floris/tools/flow_visualization.py rename to floris/flow_visualization.py index b55ed6f9c..5d40d5dc9 100644 --- a/floris/tools/flow_visualization.py +++ b/floris/flow_visualization.py @@ -15,10 +15,10 @@ from matplotlib import rcParams from scipy.spatial import ConvexHull -from floris.simulation import Floris -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT -from floris.tools.cut_plane import CutPlane -from floris.tools.floris_interface import FlorisInterface +from floris import FlorisModel +from floris.core import Core +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.cut_plane import CutPlane from floris.type_dec import ( floris_array_converter, NDArrayFloat, @@ -195,7 +195,7 @@ def visualize_cut_plane( def visualize_heterogeneous_cut_plane( cut_plane, - fi, + fmodel, ax=None, vel_component='u', min_speed=None, @@ -215,7 +215,7 @@ def visualize_heterogeneous_cut_plane( Args: cut_plane (:py:class:`~.tools.cut_plane.CutPlane`): 2D plane through wind plant. - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): FlorisInterface object. + fmodel (:py:class:`~.floris_model.FlorisModel`): FlorisModel object. ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. Defaults to None. vel_component (str, optional): The velocity component that the cut plane is @@ -297,8 +297,8 @@ def visualize_heterogeneous_cut_plane( points = np.array( list( zip( - fi.floris.flow_field.heterogenous_inflow_config['x'], - fi.floris.flow_field.heterogenous_inflow_config['y'], + fmodel.core.flow_field.heterogenous_inflow_config['x'], + fmodel.core.flow_field.heterogenous_inflow_config['y'], ) ) ) @@ -423,7 +423,7 @@ def plot_rotor_values( figure objects are returned for custom editing. Example: - from floris.tools.visualization import plot_rotor_values + from floris.visualization import plot_rotor_values plot_rotor_values(floris.flow_field.u, findex=0, n_rows=1, ncols=4) plot_rotor_values(floris.flow_field.v, findex=0, n_rows=1, ncols=4) plot_rotor_values(floris.flow_field.w, findex=0, n_rows=1, ncols=4, show=True) @@ -472,7 +472,7 @@ def plot_rotor_values( plt.show() def calculate_horizontal_plane_with_turbines( - fi_in, + fmodel_in, x_resolution=200, y_resolution=200, x_bounds=None, @@ -493,12 +493,12 @@ def calculate_horizontal_plane_with_turbines( and the flow field is reset to its initial state for every new location. Then, the local velocities are put into a DataFrame and then into a CutPlane. This method is much slower than - `FlorisInterface.calculate_horizontal_plane`, but it is helpful + `FlorisModel.calculate_horizontal_plane`, but it is helpful for models where the visualization capability is not yet available. Args: - fi_in (:py:class:`floris.tools.floris_interface.FlorisInterface`): - Preinitialized FlorisInterface object. + fmodel_in (:py:class:`floris.floris_model.FlorisModel`): + Preinitialized FlorisModel object. x_resolution (float, optional): Output array resolution. Defaults to 200 points. y_resolution (float, optional): Output array resolution. Defaults to 200 points. x_bounds (tuple, optional): Limits of output array (in m). Defaults to None. @@ -513,32 +513,32 @@ def calculate_horizontal_plane_with_turbines( :py:class:`~.tools.cut_plane.CutPlane`: containing values of x, y, u, v, w """ - # Make a local copy of fi to avoid editing passed in fi - fi = copy.deepcopy(fi_in) + # Make a local copy of fmodel to avoid editing passed in fmodel + fmodel = copy.deepcopy(fmodel_in) - # If wd/ws not provided, use what is set in fi + # If wd/ws not provided, use what is set in fmodel if wd is None: - wd = fi.floris.flow_field.wind_directions + wd = fmodel.core.flow_field.wind_directions if ws is None: - ws = fi.floris.flow_field.wind_speeds - fi.check_wind_condition_for_viz(wd=wd, ws=ws) + ws = fmodel.core.flow_field.wind_speeds + fmodel.check_wind_condition_for_viz(wd=wd, ws=ws) # Set the ws and wd - fi.set( + fmodel.set( wind_directions=wd, wind_speeds=ws, yaw_angles=yaw_angles, power_setpoints=power_setpoints, disable_turbines=disable_turbines ) - yaw_angles = fi.floris.farm.yaw_angles - power_setpoints = fi.floris.farm.power_setpoints + yaw_angles = fmodel.core.farm.yaw_angles + power_setpoints = fmodel.core.farm.power_setpoints # Grab the turbine layout - layout_x = copy.deepcopy(fi.layout_x) - layout_y = copy.deepcopy(fi.layout_y) - turbine_types = copy.deepcopy(fi.floris.farm.turbine_type) - D = fi.floris.farm.rotor_diameters_sorted[0, 0] + layout_x = copy.deepcopy(fmodel.layout_x) + layout_y = copy.deepcopy(fmodel.layout_y) + turbine_types = copy.deepcopy(fmodel.core.farm.turbine_type) + D = fmodel.core.farm.rotor_diameters_sorted[0, 0] # Declare a new layout array with an extra turbine layout_x_test = np.append(layout_x,[0]) @@ -550,10 +550,10 @@ def calculate_horizontal_plane_with_turbines( turbine_types_test = [turbine_types[0] for i in range(len(layout_x))] + ['nrel_5MW'] else: turbine_types_test = np.append(turbine_types, 'nrel_5MW').tolist() - yaw_angles = np.append(yaw_angles, np.zeros([fi.floris.flow_field.n_findex, 1]), axis=1) + yaw_angles = np.append(yaw_angles, np.zeros([fmodel.core.flow_field.n_findex, 1]), axis=1) power_setpoints = np.append( power_setpoints, - POWER_SETPOINT_DEFAULT * np.ones([fi.floris.flow_field.n_findex, 1]), + POWER_SETPOINT_DEFAULT * np.ones([fmodel.core.flow_field.n_findex, 1]), axis=1 ) @@ -587,7 +587,7 @@ def calculate_horizontal_plane_with_turbines( # Place the test turbine at this location and calculate wake layout_x_test[-1] = x layout_y_test[-1] = y - fi.set( + fmodel.set( layout_x=layout_x_test, layout_y=layout_y_test, yaw_angles=yaw_angles, @@ -595,11 +595,11 @@ def calculate_horizontal_plane_with_turbines( disable_turbines=disable_turbines, turbine_type=turbine_types_test ) - fi.run() + fmodel.run() # Get the velocity of that test turbines central point - center_point = int(np.floor(fi.floris.flow_field.u[0,-1].shape[0] / 2.0)) - u_results[idx] = fi.floris.flow_field.u[0,-1,center_point,center_point] + center_point = int(np.floor(fmodel.core.flow_field.u[0,-1].shape[0] / 2.0)) + u_results[idx] = fmodel.core.flow_field.u[0,-1,center_point,center_point] # Increment index idx = idx + 1 diff --git a/floris/tools/layout_visualization.py b/floris/layout_visualization.py similarity index 87% rename from floris/tools/layout_visualization.py rename to floris/layout_visualization.py index 756fb35c9..c064059c6 100644 --- a/floris/tools/layout_visualization.py +++ b/floris/layout_visualization.py @@ -13,21 +13,21 @@ import pandas as pd from scipy.spatial.distance import pdist, squareform -from floris.tools import FlorisInterface +from floris import FlorisModel from floris.utilities import rotate_coordinates_rel_west, wind_delta def plot_turbine_points( - fi: FlorisInterface, + fmodel: FlorisModel, ax: plt.Axes = None, turbine_indices: List[int] = None, plotting_dict: Dict[str, Any] = {}, ) -> plt.Axes: """ - Plots turbine layout from a FlorisInterface object. + Plots turbine layout from a FlorisModel object. Args: - fi (FlorisInterface): The FlorisInterface object containing layout data. + fmodel (FlorisModel): The FlorisModel object containing layout data. ax (plt.Axes, optional): An existing axes object to plot on. If None, a new figure and axes will be created. Defaults to None. turbine_indices (List[int], optional): A list of turbine indices to plot. @@ -53,11 +53,11 @@ def plot_turbine_points( # If turbine_indices is not none, make sure all elements correspond to real indices if turbine_indices is not None: try: - fi.layout_x[turbine_indices] + fmodel.layout_x[turbine_indices] except IndexError: raise IndexError("turbine_indices does not correspond to turbine indices in fi") else: - turbine_indices = list(range(len(fi.layout_x))) + turbine_indices = list(range(len(fmodel.layout_x))) # Generate plotting dictionary default_plotting_dict = { @@ -70,8 +70,8 @@ def plot_turbine_points( # Plot ax.plot( - fi.layout_x[turbine_indices], - fi.layout_y[turbine_indices], + fmodel.layout_x[turbine_indices], + fmodel.layout_y[turbine_indices], linestyle="None", **plotting_dict, ) @@ -83,7 +83,7 @@ def plot_turbine_points( def plot_turbine_labels( - fi: FlorisInterface, + fmodel: FlorisModel, ax: plt.Axes = None, turbine_names: List[str] = None, turbine_indices: List[int] = None, @@ -96,7 +96,7 @@ def plot_turbine_labels( Adds turbine labels to a turbine layout plot. Args: - fi (FlorisInterface): The FlorisInterface object containing layout data. + fmodel (FlorisModel): The FlorisModel object containing layout data. ax (plt.Axes, optional): An existing axes object to plot on. If None, a new figure and axes will be created. Defaults to None. turbine_names (List[str], optional): Custom turbine labels. If None, @@ -132,26 +132,28 @@ def plot_turbine_labels( # If turbine names not none, confirm has correct number of turbines if turbine_names is not None: - if len(turbine_names) != len(fi.layout_x): - raise ValueError("Length of turbine_names not equal to number turbines in fi object") + if len(turbine_names) != len(fmodel.layout_x): + raise ValueError( + "Length of turbine_names not equal to number turbines in fmodel object" + ) else: # Assign simple default numbering - turbine_names = [f"{i:03d}" for i in range(len(fi.layout_x))] + turbine_names = [f"{i:03d}" for i in range(len(fmodel.layout_x))] # If label_offset is None, use default value of r/8 if label_offset is None: - rotor_diameters = fi.floris.farm.rotor_diameters.flatten() + rotor_diameters = fmodel.core.farm.rotor_diameters.flatten() r = rotor_diameters[0] / 2.0 label_offset = r / 8.0 # If turbine_indices is not none, make sure all elements correspond to real indices if turbine_indices is not None: try: - fi.layout_x[turbine_indices] + fmodel.layout_x[turbine_indices] except IndexError: raise IndexError("turbine_indices does not correspond to turbine indices in fi") else: - turbine_indices = list(range(len(fi.layout_x))) + turbine_indices = list(range(len(fmodel.layout_x))) # Generate plotting dictionary default_plotting_dict = { @@ -167,15 +169,15 @@ def plot_turbine_labels( for ti in turbine_indices: if not show_bbox: ax.text( - fi.layout_x[ti] + label_offset, - fi.layout_y[ti] + label_offset, + fmodel.layout_x[ti] + label_offset, + fmodel.layout_y[ti] + label_offset, turbine_names[ti], **plotting_dict, ) else: ax.text( - fi.layout_x[ti] + label_offset, - fi.layout_y[ti] + label_offset, + fmodel.layout_x[ti] + label_offset, + fmodel.layout_y[ti] + label_offset, turbine_names[ti], bbox=bbox_dict, **plotting_dict, @@ -188,7 +190,7 @@ def plot_turbine_labels( def plot_turbine_rotors( - fi: FlorisInterface, + fmodel: FlorisModel, ax: plt.Axes = None, color: str = "k", wd: float = None, @@ -198,15 +200,15 @@ def plot_turbine_rotors( Plots wind turbine rotors on an existing axes, visually representing their yaw angles. Args: - fi (FlorisInterface): The FlorisInterface object containing layout and turbine data. + fmodel (FlorisModel): The FlorisModel object containing layout and turbine data. ax (plt.Axes, optional): An existing axes object to plot on. If None, a new figure and axes will be created. Defaults to None. color (str, optional): Color of the turbine rotor lines. Defaults to 'k' (black). wd (float, optional): Wind direction (in degrees) relative to global reference. - If None, the first wind direction in `fi.floris.flow_field.wind_directions` is used. + If None, the first wind direction in `fmodel.core.flow_field.wind_directions` is used. Defaults to None. yaw_angles (np.ndarray, optional): Array of turbine yaw angles (in degrees). If None, - the values from `fi.floris.farm.yaw_angles` are used. Defaults to None. + the values from `fmodel.core.farm.yaw_angles` are used. Defaults to None. Returns: plt.Axes: The axes object used for the plot. @@ -214,9 +216,9 @@ def plot_turbine_rotors( if not ax: _, ax = plt.subplots() if yaw_angles is None: - yaw_angles = fi.floris.farm.yaw_angles + yaw_angles = fmodel.core.farm.yaw_angles if wd is None: - wd = fi.floris.flow_field.wind_directions[0] + wd = fmodel.core.flow_field.wind_directions[0] # Rotate yaw angles to inertial frame for plotting turbines relative to wind direction yaw_angles = yaw_angles - wind_delta(np.array(wd)) @@ -229,8 +231,8 @@ def plot_turbine_rotors( if yaw_angles.ndim == 2: yaw_angles = yaw_angles[0, :] - rotor_diameters = fi.floris.farm.rotor_diameters.flatten() - for x, y, yaw, d in zip(fi.layout_x, fi.layout_y, yaw_angles, rotor_diameters): + rotor_diameters = fmodel.core.farm.rotor_diameters.flatten() + for x, y, yaw, d in zip(fmodel.layout_x, fmodel.layout_y, yaw_angles, rotor_diameters): R = d / 2.0 x_0 = x + np.sin(np.deg2rad(yaw)) * R x_1 = x - np.sin(np.deg2rad(yaw)) * R @@ -359,7 +361,7 @@ def put_label(i: int) -> None: def plot_waking_directions( - fi: FlorisInterface, + fmodel: FlorisModel, ax: plt.Axes = None, turbine_indices: List[int] = None, wake_plotting_dict: Dict[str, Any] = {}, @@ -373,7 +375,7 @@ def plot_waking_directions( Plots lines representing potential waking directions between wind turbines in a layout. Args: - fi (FlorisInterface): Instantiated FlorisInterface object containing layout data. + fmodel (FlorisModel): Instantiated FlorisModel object containing layout data. ax (plt.Axes, optional): An existing axes object to plot on. If None, a new figure and axes will be created. Defaults to None. turbine_indices (List[int], optional): Indices of turbines to include in the plot. @@ -408,14 +410,14 @@ def plot_waking_directions( # If turbine_indices is not none, make sure all elements correspond to real indices if turbine_indices is not None: try: - fi.layout_x[turbine_indices] + fmodel.layout_x[turbine_indices] except IndexError: raise IndexError("turbine_indices does not correspond to turbine indices in fi") else: - turbine_indices = list(range(len(fi.layout_x))) + turbine_indices = list(range(len(fmodel.layout_x))) - layout_x = fi.layout_x[turbine_indices] - layout_y = fi.layout_y[turbine_indices] + layout_x = fmodel.layout_x[turbine_indices] + layout_y = fmodel.layout_y[turbine_indices] N_turbs = len(layout_x) # Combine default plotting options @@ -426,13 +428,13 @@ def plot_waking_directions( } wake_plotting_dict = {**def_wake_plotting_dict, **wake_plotting_dict} - # N_turbs = len(fi.floris.farm.turbine_definitions) + # N_turbs = len(fmodel.core.farm.turbine_definitions) if D is None: - D = fi.floris.farm.turbine_definitions[0]["rotor_diameter"] + D = fmodel.core.farm.turbine_definitions[0]["rotor_diameter"] # TODO: build out capability to use multiple diameters, if of interest. # D = np.array([turb['rotor_diameter'] for turb in - # fi.floris.farm.turbine_definitions]) + # fmodel.core.farm.turbine_definitions]) # else: # D = D*np.ones(N_turbs) @@ -468,7 +470,11 @@ def plot_waking_directions( # and i in layout_plotting_dict["turbine_indices"] # and j in layout_plotting_dict["turbine_indices"] ): - (h,) = ax.plot(fi.layout_x[[i, j]], fi.layout_y[[i, j]], **wake_plotting_dict) + (h,) = ax.plot( + fmodel.layout_x[[i, j]], + fmodel.layout_y[[i, j]], + **wake_plotting_dict + ) # Only label in one direction if ~label_exists[i, j]: @@ -495,20 +501,20 @@ def plot_waking_directions( return ax -def plot_farm_terrain(fi: FlorisInterface, ax: plt.Axes = None) -> None: +def plot_farm_terrain(fmodel: FlorisModel, ax: plt.Axes = None) -> None: """ Creates a filled contour plot visualizing terrain-corrected wind turbine hub heights. Args: - fi (FlorisInterface): The FlorisInterface object containing layout data. + fmodel (FlorisModel): The FlorisModel object containing layout data. ax (plt.Axes, optional): An existing axes object to plot on. If None, a new figure and axes will be created. Defaults to None. """ if not ax: _, ax = plt.subplots() - hub_heights = fi.floris.farm.hub_heights.flatten() - cntr = ax.tricontourf(fi.layout_x, fi.layout_y, hub_heights, levels=14, cmap="RdBu_r") + hub_heights = fmodel.core.farm.hub_heights.flatten() + cntr = ax.tricontourf(fmodel.layout_x, fmodel.layout_y, hub_heights, levels=14, cmap="RdBu_r") ax.get_figure().colorbar( cntr, diff --git a/floris/tools/optimization/__init__.py b/floris/optimization/__init__.py similarity index 100% rename from floris/tools/optimization/__init__.py rename to floris/optimization/__init__.py diff --git a/floris/tools/optimization/layout_optimization/__init__.py b/floris/optimization/layout_optimization/__init__.py similarity index 100% rename from floris/tools/optimization/layout_optimization/__init__.py rename to floris/optimization/layout_optimization/__init__.py diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_base.py b/floris/optimization/layout_optimization/layout_optimization_base.py similarity index 86% rename from floris/tools/optimization/layout_optimization/layout_optimization_base.py rename to floris/optimization/layout_optimization/layout_optimization_base.py index ba5a86751..c8e192d1a 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_base.py +++ b/floris/optimization/layout_optimization/layout_optimization_base.py @@ -3,13 +3,13 @@ import numpy as np from shapely.geometry import LineString, Polygon -from floris.tools import TimeSeries -from floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric import ( +from floris import TimeSeries +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( YawOptimizationGeometric, ) -from floris.tools.wind_data import WindDataBase +from floris.wind_data import WindDataBase -from ....logging_manager import LoggingManager +from ...logging_manager import LoggingManager class LayoutOptimization(LoggingManager): @@ -18,7 +18,7 @@ class LayoutOptimization(LoggingManager): but should be subclassed by a specific optimization method. Args: - fi (FlorisInterface): A FlorisInterface object. + fmodel (FlorisModel): A FlorisModel object. boundaries (iterable(float, float)): Pairs of x- and y-coordinates that represent the boundary's vertices (m). wind_data (TimeSeries | WindRose): A TimeSeries or WindRose object @@ -29,8 +29,8 @@ class LayoutOptimization(LoggingManager): enable_geometric_yaw (bool, optional): If True, enables geometric yaw optimization. Defaults to False. """ - def __init__(self, fi, boundaries, wind_data, min_dist=None, enable_geometric_yaw=False): - self.fi = fi.copy() + def __init__(self, fmodel, boundaries, wind_data, min_dist=None, enable_geometric_yaw=False): + self.fmodel = fmodel.copy() self.boundaries = boundaries self.enable_geometric_yaw = enable_geometric_yaw @@ -59,12 +59,12 @@ def __init__(self, fi, boundaries, wind_data, min_dist=None, enable_geometric_ya # Establish geometric yaw class if self.enable_geometric_yaw: self.yaw_opt = YawOptimizationGeometric( - fi, + fmodel, minimum_yaw_angle=-30.0, maximum_yaw_angle=30.0, ) - self.initial_AEP = fi.get_farm_AEP_with_wind_data(self.wind_data) + self.initial_AEP = fmodel.get_farm_AEP_with_wind_data(self.wind_data) def __str__(self): return "layout" @@ -79,7 +79,7 @@ def _get_geoyaw_angles(self): # NOTE: requires that child class saves x and y locations # as self.x and self.y and updates them during optimization. if self.enable_geometric_yaw: - self.yaw_opt.fi_subset.set(layout_x=self.x, layout_y=self.y) + self.yaw_opt.fmodel_subset.set(layout_x=self.x, layout_y=self.y) df_opt = self.yaw_opt.optimize() self.yaw_angles = np.vstack(df_opt['yaw_angles_opt'])[:, :] else: @@ -137,9 +137,9 @@ def nturbs(self): Returns: nturbs (int): The number of turbines in the FLORIS object. """ - self._nturbs = self.fi.floris.farm.n_turbines + self._nturbs = self.fmodel.core.farm.n_turbines return self._nturbs @property def rotor_diameter(self): - return self.fi.floris.farm.rotor_diameters_sorted[0][0] + return self.fmodel.core.farm.rotor_diameters_sorted[0][0] diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py b/floris/optimization/layout_optimization/layout_optimization_boundary_grid.py similarity index 99% rename from floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py rename to floris/optimization/layout_optimization/layout_optimization_boundary_grid.py index a17b3e220..c43310017 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py +++ b/floris/optimization/layout_optimization/layout_optimization_boundary_grid.py @@ -14,7 +14,7 @@ class LayoutOptimizationBoundaryGrid(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, start, x_spacing, @@ -27,7 +27,7 @@ def __init__( n_boundary_turbines=None, boundary_spacing=None, ): - self.fi = fi + self.fmodel = fmodel self.boundary_x = np.array([val[0] for val in boundaries]) self.boundary_y = np.array([val[1] for val in boundaries]) @@ -612,13 +612,13 @@ def reinitialize_xy(self): self.boundary_spacing, ) - self.fi.set(layout=(layout_x, layout_y)) + self.fmodel.set(layout=(layout_x, layout_y)) def plot_layout(self): plt.figure(figsize=(9, 6)) fontsize = 16 - plt.plot(self.fi.layout_x, self.fi.layout_y, "ob") + plt.plot(self.fmodel.layout_x, self.fmodel.layout_y, "ob") # plt.plot(locsx, locsy, "or") plt.xlabel("x (m)", fontsize=fontsize) diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py similarity index 93% rename from floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py rename to floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py index f0b519254..9d26bc616 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py +++ b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py @@ -10,7 +10,7 @@ class LayoutOptimizationPyOptSparse(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, wind_data, min_dist=None, @@ -21,11 +21,11 @@ def __init__( hotStart=None, enable_geometric_yaw=False, ): - super().__init__(fi, boundaries, wind_data=wind_data, min_dist=min_dist, + super().__init__(fmodel, boundaries, wind_data=wind_data, min_dist=min_dist, enable_geometric_yaw=enable_geometric_yaw) - self.x0 = self._norm(self.fi.layout_x, self.xmin, self.xmax) - self.y0 = self._norm(self.fi.layout_y, self.ymin, self.ymax) + self.x0 = self._norm(self.fmodel.layout_x, self.xmin, self.xmax) + self.y0 = self._norm(self.fmodel.layout_y, self.ymin, self.ymax) self.storeHistory = storeHistory self.timeLimit = timeLimit @@ -94,13 +94,13 @@ def _obj_func(self, varDict): # Compute turbine yaw angles using PJ's geometric code (if enabled) yaw_angles = self._get_geoyaw_angles() # Update turbine map with turbine locations and yaw angles - self.fi.set(layout_x=self.x, layout_y=self.y, yaw_angles=yaw_angles) + self.fmodel.set(layout_x=self.x, layout_y=self.y, yaw_angles=yaw_angles) # Compute the objective function funcs = {} funcs["obj"] = ( - -1 * self.fi.get_farm_AEP_with_wind_data(self.wind_data) + -1 * self.fmodel.get_farm_AEP_with_wind_data(self.wind_data) / self.initial_AEP ) diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py similarity index 97% rename from floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py rename to floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py index 7b0ccbe03..aa8d9f54e 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py +++ b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py @@ -10,7 +10,7 @@ class LayoutOptimizationPyOptSparse(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, wind_data, min_dist=None, @@ -20,7 +20,7 @@ def __init__( storeHistory='hist.hist', hotStart=None ): - super().__init__(fi, boundaries, wind_data=wind_data, min_dist=min_dist) + super().__init__(fmodel, boundaries, wind_data=wind_data, min_dist=min_dist) self._reinitialize(solver=solver, optOptions=optOptions) self.storeHistory = storeHistory @@ -88,8 +88,8 @@ def _obj_func(self, varDict): self.parse_opt_vars(varDict) # Update turbine map with turbince locations - # self.fi.reinitialize(layout=[self.x, self.y]) - # self.fi.calculate_wake() + # self.fmodel.reinitialize(layout=[self.x, self.y]) + # self.fmodel.calculate_wake() # Compute the objective function funcs = {} diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_scipy.py b/floris/optimization/layout_optimization/layout_optimization_scipy.py similarity index 94% rename from floris/tools/optimization/layout_optimization/layout_optimization_scipy.py rename to floris/optimization/layout_optimization/layout_optimization_scipy.py index a2a8bef6f..23c866071 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_scipy.py +++ b/floris/optimization/layout_optimization/layout_optimization_scipy.py @@ -11,7 +11,7 @@ class LayoutOptimizationScipy(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, wind_data, bnds=None, @@ -24,7 +24,7 @@ def __init__( _summary_ Args: - fi (_type_): _description_ + fmodel (FlorisModel): A FlorisModel object. boundaries (iterable(float, float)): Pairs of x- and y-coordinates that represent the boundary's vertices (m). wind_data (TimeSeries | WindRose): A TimeSeries or WindRose object @@ -39,7 +39,7 @@ def __init__( optOptions (dict, optional): Dicitonary for setting the optimization options. Defaults to None. """ - super().__init__(fi, boundaries, min_dist=min_dist, wind_data=wind_data, + super().__init__(fmodel, boundaries, min_dist=min_dist, wind_data=wind_data, enable_geometric_yaw=enable_geometric_yaw) self.boundaries_norm = [ @@ -51,10 +51,10 @@ def __init__( ] self.x0 = [ self._norm(x, self.xmin, self.xmax) - for x in self.fi.layout_x + for x in self.fmodel.layout_x ] + [ self._norm(y, self.ymin, self.ymax) - for y in self.fi.layout_y + for y in self.fmodel.layout_y ] if bnds is not None: self.bnds = bnds @@ -97,9 +97,9 @@ def _obj_func(self, locs): self._change_coordinates(locs_unnorm) # Compute turbine yaw angles using PJ's geometric code (if enabled) yaw_angles = self._get_geoyaw_angles() - self.fi.set(yaw_angles=yaw_angles) + self.fmodel.set(yaw_angles=yaw_angles) - return (-1 * self.fi.get_farm_AEP_with_wind_data(self.wind_data) / + return (-1 * self.fmodel.get_farm_AEP_with_wind_data(self.wind_data) / self.initial_AEP) @@ -113,7 +113,7 @@ def _change_coordinates(self, locs): self.y = layout_y # Update the turbine map in floris - self.fi.set(layout_x=layout_x, layout_y=layout_y) + self.fmodel.set(layout_x=layout_x, layout_y=layout_y) def _generate_constraints(self): tmp1 = { diff --git a/floris/tools/optimization/other/__init__.py b/floris/optimization/other/__init__.py similarity index 100% rename from floris/tools/optimization/other/__init__.py rename to floris/optimization/other/__init__.py diff --git a/floris/tools/optimization/other/boundary_grid.py b/floris/optimization/other/boundary_grid.py similarity index 97% rename from floris/tools/optimization/other/boundary_grid.py rename to floris/optimization/other/boundary_grid.py index 38b9816e5..9d160b8a6 100644 --- a/floris/tools/optimization/other/boundary_grid.py +++ b/floris/optimization/other/boundary_grid.py @@ -243,13 +243,12 @@ class BoundaryGrid: def __init__(self, fi): """ Initializes a BoundaryGrid object by assigning a - FlorisInterface object. + FlorisModel object. Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. + fmodel (FlorisModel): A FlorisModel object. """ - self.fi = fi + self.fmodel = fi self.n_boundary_turbs = 0 self.start = 0.0 @@ -332,7 +331,7 @@ def reinitialize_xy(self): eps=self.eps, ) - self.fi.reinitialize_flow_field(layout_array=(layout_x, layout_y)) + self.fmodel.reinitialize_flow_field(layout_array=(layout_x, layout_y)) if __name__ == "__main__": diff --git a/floris/tools/optimization/yaw_optimization/__init__.py b/floris/optimization/yaw_optimization/__init__.py similarity index 100% rename from floris/tools/optimization/yaw_optimization/__init__.py rename to floris/optimization/yaw_optimization/__init__.py diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py b/floris/optimization/yaw_optimization/yaw_optimization_base.py similarity index 93% rename from floris/tools/optimization/yaw_optimization/yaw_optimization_base.py rename to floris/optimization/yaw_optimization/yaw_optimization_base.py index 5964c2ae1..5608f58f4 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py +++ b/floris/optimization/yaw_optimization/yaw_optimization_base.py @@ -12,14 +12,14 @@ class YawOptimization(LoggingManager): """ - YawOptimization is a subclass of :py:class:`floris.tools.optimization.scipy. + YawOptimization is a subclass of :py:class:`floris.optimization.scipy. Optimization` that is used to optimize the yaw angles of all turbines in a Floris Farm for a single set of inflow conditions using the SciPy optimize package. """ def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, yaw_angles_baseline=None, @@ -31,12 +31,11 @@ def __init__( verify_convergence=False, ): """ - Instantiate YawOptimization object with a FlorisInterface object + Instantiate YawOptimization object with a FlorisModel object and assign parameter values. Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. + fmodel (:py:class:`~.floris_model.FlorisModel`): A FlorisModel object. minimum_yaw_angle (float or ndarray): Minimum constraint on yaw angle (deg). If a single value specified, assumes this value for all turbines. If a 1D array is specified, assumes these @@ -100,11 +99,11 @@ def __init__( """ # Save turbine object to self - self.fi = fi.copy() - self.nturbs = len(self.fi.layout_x) + self.fmodel = fmodel.copy() + self.nturbs = len(self.fmodel.layout_x) # # Check floris options - # if self.fi.floris.flow_field.n_wind_speeds > 1: + # if self.fmodel.core.flow_field.n_wind_speeds > 1: # raise NotImplementedError( # "Optimizer currently does not support more than one wind" + # " speed. Please assign FLORIS a single wind speed." @@ -116,7 +115,7 @@ def __init__( yaw_angles_baseline = self._unpack_variable(yaw_angles_baseline) self.yaw_angles_baseline = yaw_angles_baseline else: - b = self.fi.floris.farm.yaw_angles + b = self.fmodel.core.farm.yaw_angles self.yaw_angles_baseline = self._unpack_variable(b) if np.any(np.abs(b) > 0.0): print( @@ -206,7 +205,7 @@ def _unpack_variable(self, variable, subset=False): # If one-dimensional array, copy over to all atmos. conditions variable = np.tile( variable, - (self.fi.floris.flow_field.n_findex, 1) + (self.fmodel.core.flow_field.n_findex, 1) ) @@ -225,8 +224,8 @@ def _reduce_control_problem(self): self.turbs_to_opt = (self.maximum_yaw_angle - self.minimum_yaw_angle >= 0.001) # Initialize subset variables as full set - self.fi_subset = self.fi.copy() - n_findex_subset = copy.deepcopy(self.fi.floris.flow_field.n_findex) + self.fmodel_subset = self.fmodel.copy() + n_findex_subset = copy.deepcopy(self.fmodel.core.flow_field.n_findex) minimum_yaw_angle_subset = copy.deepcopy(self.minimum_yaw_angle) maximum_yaw_angle_subset = copy.deepcopy(self.maximum_yaw_angle) x0_subset = copy.deepcopy(self.x0) @@ -237,9 +236,9 @@ def _reduce_control_problem(self): # Define which turbines to optimize for if self.exclude_downstream_turbines: - for iw, wd in enumerate(self.fi.floris.flow_field.wind_directions): + for iw, wd in enumerate(self.fmodel.core.flow_field.wind_directions): # Remove turbines from turbs_to_opt that are downstream - downstream_turbines = derive_downstream_turbines(self.fi, wd) + downstream_turbines = derive_downstream_turbines(self.fmodel, wd) downstream_turbines = np.array(downstream_turbines, dtype=int) self.turbs_to_opt[iw, downstream_turbines] = False turbs_to_opt_subset = copy.deepcopy(self.turbs_to_opt) # Update @@ -326,19 +325,19 @@ def _calculate_farm_power( farm_power (float): Weighted wind farm power. """ # Unpack all variables, whichever are defined. - fi_subset = copy.deepcopy(self.fi_subset) + fmodel_subset = copy.deepcopy(self.fmodel_subset) if wd_array is None: - wd_array = fi_subset.floris.flow_field.wind_directions + wd_array = fmodel_subset.core.flow_field.wind_directions if ws_array is None: - ws_array = fi_subset.floris.flow_field.wind_speeds + ws_array = fmodel_subset.core.flow_field.wind_speeds if ti_array is None: - ti_array = fi_subset.floris.flow_field.turbulence_intensities + ti_array = fmodel_subset.core.flow_field.turbulence_intensities if yaw_angles is None: yaw_angles = self._yaw_angles_baseline_subset if turbine_weights is None: turbine_weights = self._turbine_weights_subset if heterogeneous_speed_multipliers is not None: - fi_subset.floris.flow_field.\ + fmodel_subset.core.flow_field.\ heterogenous_inflow_config['speed_multipliers'] = heterogeneous_speed_multipliers # Ensure format [incompatible with _subset notation] @@ -349,14 +348,14 @@ def _calculate_farm_power( # Calculate solutions turbine_power = np.zeros_like(self._minimum_yaw_angle_subset[:, :]) - fi_subset.set( + fmodel_subset.set( wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array, yaw_angles=yaw_angles, ) - fi_subset.run() - turbine_power = fi_subset.get_turbine_powers() + fmodel_subset.run() + turbine_power = fmodel_subset.get_turbine_powers() # Multiply with turbine weighing terms turbine_power_weighted = np.multiply(turbine_weights, turbine_power) @@ -401,9 +400,9 @@ def _finalize(self, farm_power_opt_subset=None, yaw_angles_opt_subset=None): df_list.append( pd.DataFrame( { - "wind_direction": self.fi.floris.flow_field.wind_directions, - "wind_speed": self.fi.floris.flow_field.wind_speeds, - "turbulence_intensity": self.fi.floris.flow_field.turbulence_intensities, + "wind_direction": self.fmodel.core.flow_field.wind_directions, + "wind_speed": self.fmodel.core.flow_field.wind_speeds, + "turbulence_intensity": self.fmodel.core.flow_field.turbulence_intensities, "yaw_angles_opt": list(self.yaw_angles_opt[:, :]), "farm_power_opt": None if self.farm_power_opt is None @@ -493,11 +492,11 @@ def _verify_solutions_for_convergence( # we copy the atmospheric conditions n_turbs times and for each # copy of atmospheric conditions, we reset that turbine's yaw angle # to its baseline value for all conditions. - n_turbs = len(self.fi.layout_x) + n_turbs = len(self.fmodel.layout_x) sp = (n_turbs, 1) # Tile shape for matrix expansion - wd_array_nominal = self.fi_subset.floris.flow_field.wind_directions - ws_array_nominal = self.fi_subset.floris.flow_field.wind_speeds - ti_array_nominal = self.fi_subset.floris.flow_field.turbulence_intensities + wd_array_nominal = self.fmodel_subset.core.flow_field.wind_directions + ws_array_nominal = self.fmodel_subset.core.flow_field.wind_speeds + ti_array_nominal = self.fmodel_subset.core.flow_field.turbulence_intensities n_wind_directions = len(wd_array_nominal) yaw_angles_verify = np.tile(yaw_angles_opt_subset, sp) yaw_angles_bl_verify = np.tile(yaw_angles_baseline_subset, sp) @@ -565,7 +564,7 @@ def _verify_solutions_for_convergence( diff_uplift = dP_old - dP_new ids_max_loss = np.where(np.nanmax(diff_uplift) == diff_uplift) jj = (ids_max_loss[0][0], ids_max_loss[1][0]) - ws_array_nominal = self.fi_subset.floris.flow_field.wind_speeds + ws_array_nominal = self.fmodel_subset.core.flow_field.wind_speeds print( "Nullified the optimal yaw offset for {:d}".format(n) + " conditions and turbines." diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py b/floris/optimization/yaw_optimization/yaw_optimization_tools.py similarity index 94% rename from floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py rename to floris/optimization/yaw_optimization/yaw_optimization_tools.py index 7b13ece91..dedf8f057 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py +++ b/floris/optimization/yaw_optimization/yaw_optimization_tools.py @@ -4,7 +4,7 @@ import pandas as pd -def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=False): +def derive_downstream_turbines(fmodel, wind_direction, wake_slope=0.30, plot_lines=False): """Determine which turbines have no effect on other turbines in the farm, i.e., which turbines have wakes that do not impact the other turbines in the farm. This allows the user to exclude these turbines @@ -23,7 +23,7 @@ def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=F time compared to FLORIS. Args: - fi ([floris object]): FLORIS object of the farm of interest. + fmodel (FlorisModel): A FlorisModel object. wind_direction (float): The wind direction in the FLORIS frame of reference for which the downstream turbines are to be determined. wake_slope (float, optional): linear slope of the wake (dy/dx) @@ -37,9 +37,9 @@ def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=F """ # Get farm layout - x = fi.layout_x - y = fi.layout_y - D = np.ones_like(x) * fi.floris.farm.rotor_diameters_sorted[0][0] + x = fmodel.layout_x + y = fmodel.layout_y + D = np.ones_like(x) * fmodel.core.farm.rotor_diameters_sorted[0][0] n_turbs = len(x) # Rotate farm and determine freestream/waked turbines diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py similarity index 96% rename from floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py rename to floris/optimization/yaw_optimization/yaw_optimizer_geometric.py index 8607ee596..e78d48c9d 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py @@ -9,24 +9,24 @@ class YawOptimizationGeometric(YawOptimization): """ YawOptimizationGeometric is a subclass of - :py:class:`floris.tools.optimization.general_library.YawOptimization` that is + :py:class:`floris.optimization.general_library.YawOptimization` that is used to provide a rough estimate of optimal yaw angles based purely on the wind farm geometry. Main use case is for coupled layout and yaw optimization. """ def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, ): """ - Instantiate YawOptimizationGeometric object with a FlorisInterface + Instantiate YawOptimizationGeometric object with a FlorisModel object assign parameter values. """ super().__init__( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, calc_baseline_power=False @@ -42,14 +42,14 @@ def optimize(self): array is equal in length to the number of turbines in the farm. """ # Loop through every WD individually. WS ignored! - wd_array = self.fi_subset.floris.flow_field.wind_directions + wd_array = self.fmodel_subset.core.flow_field.wind_directions for nwdi, wd in enumerate(wd_array): self._yaw_angles_opt_subset[nwdi, :] = geometric_yaw( - self.fi_subset.layout_x, - self.fi_subset.layout_y, + self.fmodel_subset.layout_x, + self.fmodel_subset.layout_y, wd, - self.fi.floris.farm.turbine_definitions[0]["rotor_diameter"], + self.fmodel.core.farm.turbine_definitions[0]["rotor_diameter"], top_left_yaw_upper=self.maximum_yaw_angle[0, 0], bottom_left_yaw_upper=self.maximum_yaw_angle[0, 0], top_left_yaw_lower=self.minimum_yaw_angle[0, 0], diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py b/floris/optimization/yaw_optimization/yaw_optimizer_scipy.py similarity index 86% rename from floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py rename to floris/optimization/yaw_optimization/yaw_optimizer_scipy.py index 735296b58..b62649117 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_scipy.py @@ -8,14 +8,14 @@ class YawOptimizationScipy(YawOptimization): """ YawOptimizationScipy is a subclass of - :py:class:`floris.tools.optimization.general_library.YawOptimization` that is + :py:class:`floris.optimization.general_library.YawOptimization` that is used to optimize the yaw angles of all turbines in a Floris Farm for a single set of inflow conditions using the SciPy optimize package. """ def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, yaw_angles_baseline=None, @@ -27,7 +27,7 @@ def __init__( verify_convergence=False, ): """ - Instantiate YawOptimizationScipy object with a FlorisInterface object + Instantiate YawOptimizationScipy object with a FlorisModel object and assign parameter values. """ if opt_options is None: @@ -41,7 +41,7 @@ def __init__( } super().__init__( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, yaw_angles_baseline=yaw_angles_baseline, @@ -68,12 +68,12 @@ def optimize(self): array is equal in length to the number of turbines in the farm. """ # Loop through every wind condition individually - wd_array = self.fi_subset.floris.flow_field.wind_directions - ws_array = self.fi_subset.floris.flow_field.wind_speeds - ti_array = self.fi_subset.floris.flow_field.turbulence_intensities + wd_array = self.fmodel_subset.core.flow_field.wind_directions + ws_array = self.fmodel_subset.core.flow_field.wind_speeds + ti_array = self.fmodel_subset.core.flow_field.turbulence_intensities for i, (wd, ws, ti) in enumerate(zip(wd_array, ws_array, ti_array)): - self.fi_subset.set( + self.fmodel_subset.set( wind_directions=[wd], wind_speeds=[ws], turbulence_intensities=[ti] @@ -98,10 +98,10 @@ def optimize(self): turbine_weights = np.tile(turbine_weights, (1, 1)) # Handle heterogeneous inflow, if there is one - if (hasattr(self.fi.floris.flow_field, 'heterogenous_inflow_config') and - self.fi.floris.flow_field.heterogenous_inflow_config is not None): + if (hasattr(self.fmodel.core.flow_field, 'heterogenous_inflow_config') and + self.fmodel.core.flow_field.heterogenous_inflow_config is not None): het_sm_orig = np.array( - self.fi.floris.flow_field.heterogenous_inflow_config['speed_multipliers'] + self.fmodel.core.flow_field.heterogenous_inflow_config['speed_multipliers'] ) het_sm = het_sm_orig[i, :].reshape(1, -1) else: diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py b/floris/optimization/yaw_optimization/yaw_optimizer_sr.py similarity index 92% rename from floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py rename to floris/optimization/yaw_optimization/yaw_optimizer_sr.py index 2175a6fe2..c6d76b04e 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_sr.py @@ -15,7 +15,7 @@ class YawOptimizationSR(YawOptimization, LoggingManager): def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, yaw_angles_baseline=None, @@ -26,13 +26,13 @@ def __init__( verify_convergence=False, ): """ - Instantiate YawOptimizationSR object with a FlorisInterface object + Instantiate YawOptimizationSR object with a FlorisModel object and assign parameter values. """ # Initialize base class super().__init__( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, yaw_angles_baseline=yaw_angles_baseline, @@ -62,8 +62,8 @@ def __init__( # if reduce_ngrid: # for ti in range(self.nturbs): # # Force number of grid points to 2 - # self.fi.floris.farm.turbines[ti].ngrid = 2 - # self.fi.floris.farm.turbines[ti].initialize_turbine() + # self.fmodel.core.farm.turbines[ti].ngrid = 2 + # self.fmodel.core.farm.turbines[ti].initialize_turbine() # print("Reducing ngrid. Unsure if this functionality works!") # Save optimization choices to self @@ -73,10 +73,10 @@ def __init__( self._get_turbine_orders() def _get_turbine_orders(self): - layout_x = self.fi.layout_x - layout_y = self.fi.layout_y + layout_x = self.fmodel.layout_x + layout_y = self.fmodel.layout_y turbines_ordered_array = [] - for wd in self.fi_subset.floris.flow_field.wind_directions: + for wd in self.fmodel_subset.core.flow_field.wind_directions: layout_x_rot = ( np.cos((wd - 270.0) * np.pi / 180.0) * layout_x - np.sin((wd - 270.0) * np.pi / 180.0) * layout_y @@ -90,9 +90,9 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): # Define current optimal solutions and floris wind directions locally yaw_angles_opt_subset = self._yaw_angles_opt_subset farm_power_opt_subset = self._farm_power_opt_subset - wd_array_subset = self.fi_subset.floris.flow_field.wind_directions - ws_array_subset = self.fi_subset.floris.flow_field.wind_speeds - ti_array_subset = self.fi_subset.floris.flow_field.turbulence_intensities + wd_array_subset = self.fmodel_subset.core.flow_field.wind_directions + ws_array_subset = self.fmodel_subset.core.flow_field.wind_speeds + ti_array_subset = self.fmodel_subset.core.flow_field.turbulence_intensities turbine_weights_subset = self._turbine_weights_subset # Reformat yaw_angles_subset, if necessary @@ -129,10 +129,10 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): if not np.all(idx): # Now calculate farm powers for conditions we haven't yet evaluated previously start_time = timerpc() - if (hasattr(self.fi.floris.flow_field, 'heterogenous_inflow_config') and - self.fi.floris.flow_field.heterogenous_inflow_config is not None): + if (hasattr(self.fmodel.core.flow_field, 'heterogenous_inflow_config') and + self.fmodel.core.flow_field.heterogenous_inflow_config is not None): het_sm_orig = np.array( - self.fi.floris.flow_field.heterogenous_inflow_config['speed_multipliers'] + self.fmodel.core.flow_field.heterogenous_inflow_config['speed_multipliers'] ) het_sm = np.tile(het_sm_orig, (Ny, 1))[~idx, :] else: @@ -153,7 +153,7 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): farm_powers, ( Ny, - self.fi_subset.floris.flow_field.n_findex + self.fmodel_subset.core.flow_field.n_findex ) ) diff --git a/floris/tools/parallel_computing_interface.py b/floris/parallel_computing_interface.py similarity index 82% rename from floris/tools/parallel_computing_interface.py rename to floris/parallel_computing_interface.py index 7260b0305..00e749adf 100644 --- a/floris/tools/parallel_computing_interface.py +++ b/floris/parallel_computing_interface.py @@ -7,36 +7,36 @@ import pandas as pd from floris.logging_manager import LoggingManager -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR -from floris.tools.uncertainty_interface import FlorisInterface, UncertaintyInterface +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris.uncertainty_interface import FlorisModel, UncertaintyInterface def _load_local_floris_object( - fi_dict, + fmodel_dict, unc_pmfs=None, fix_yaw_in_relative_frame=False ): # Load local FLORIS object if unc_pmfs is None: - fi = FlorisInterface(fi_dict) + fmodel = FlorisModel(fmodel_dict) else: - fi = UncertaintyInterface( - fi_dict, + fmodel = UncertaintyInterface( + fmodel_dict, unc_pmfs=unc_pmfs, fix_yaw_in_relative_frame=fix_yaw_in_relative_frame, ) - return fi + return fmodel -def _get_turbine_powers_serial(fi_information, yaw_angles=None): - fi = _load_local_floris_object(*fi_information) - fi.set(yaw_angles=yaw_angles) - fi.run() - return (fi.get_turbine_powers(), fi.floris.flow_field) +def _get_turbine_powers_serial(fmodel_information, yaw_angles=None): + fmodel = _load_local_floris_object(*fmodel_information) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + return (fmodel.get_turbine_powers(), fmodel.core.flow_field) def _optimize_yaw_angles_serial( - fi_information, + fmodel_information, minimum_yaw_angle, maximum_yaw_angle, yaw_angles_baseline, @@ -47,9 +47,9 @@ def _optimize_yaw_angles_serial( verify_convergence, print_progress, ): - fi_opt = _load_local_floris_object(*fi_information) + fmodel_opt = _load_local_floris_object(*fmodel_information) yaw_opt = YawOptimizationSR( - fi=fi_opt, + fmodel=fmodel_opt, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, yaw_angles_baseline=yaw_angles_baseline, @@ -68,7 +68,7 @@ def _optimize_yaw_angles_serial( class ParallelComputingInterface(LoggingManager): def __init__( self, - fi, + fmodel, max_workers, n_wind_condition_splits, interface="multiprocessing", # Options are 'multiprocessing', 'mpi4py' or 'concurrent' @@ -77,11 +77,11 @@ def __init__( print_timings=False ): """A wrapper around the nominal floris_interface class that adds - parallel computing to common FlorisInterface properties. + parallel computing to common FlorisModel properties. Args: - fi (FlorisInterface or UncertaintyInterface object): Interactive FLORIS object used to - perform the wake and turbine calculations. Can either be a regular FlorisInterface + fmodel (FlorisModel or UncertaintyInterface object): Interactive FLORIS object used to + perform the wake and turbine calculations. Can either be a regular FlorisModel object or can be an UncertaintyInterface object. max_workers (int): Number of parallel workers, typically equal to the number of cores you have on your system or HPC. @@ -128,15 +128,15 @@ def __init__( ) # Initialize floris object and copy common properties - self.fi = fi.copy() - self.floris = self.fi.floris # Static copy as a placeholder + self.fmodel = fmodel.copy() + self.core = self.fmodel.core # Static copy as a placeholder # Save to self self._n_wind_condition_splits = n_wind_condition_splits # Save initial user input self._max_workers = max_workers # Save initial user input self.n_wind_condition_splits = int( - np.min([n_wind_condition_splits, self.fi.floris.flow_field.n_findex]) + np.min([n_wind_condition_splits, self.fmodel.core.flow_field.n_findex]) ) self.max_workers = int( np.min([max_workers, self.n_wind_condition_splits]) @@ -148,7 +148,7 @@ def __init__( def copy(self): # Make an independent copy self_copy = copy.deepcopy(self) - self_copy.fi = self.fi.copy() + self_copy.fmodel = self.fmodel.copy() return self_copy def set( @@ -166,8 +166,8 @@ def set( turbine_type=None, solver_settings=None, ): - """Pass to the FlorisInterface set function. To allow users - to directly replace a FlorisInterface object with this + """Pass to the FlorisModel set function. To allow users + to directly replace a FlorisModel object with this UncertaintyInterface object, this function is required.""" if layout is not None: @@ -178,8 +178,8 @@ def set( layout_y = layout[1] # Just passes arguments to the floris object - fi = self.fi.copy() - fi.set( + fmodel = self.fmodel.copy() + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, wind_shear=wind_shear, @@ -195,7 +195,7 @@ def set( # Reinitialize settings self.__init__( - fi=fi, + fmodel=fmodel, max_workers=self._max_workers, n_wind_condition_splits=self._n_wind_condition_splits, interface=self.interface, @@ -207,45 +207,45 @@ def _preprocessing(self, yaw_angles=None): # Format yaw angles if yaw_angles is None: yaw_angles = np.zeros(( - self.fi.floris.flow_field.n_findex, - self.fi.floris.farm.n_turbines + self.fmodel.core.flow_field.n_findex, + self.fmodel.core.farm.n_turbines )) # Prepare settings n_wind_condition_splits = self.n_wind_condition_splits n_wind_condition_splits = np.min( - [n_wind_condition_splits, self.fi.floris.flow_field.n_findex] + [n_wind_condition_splits, self.fmodel.core.flow_field.n_findex] ) # Prepare the input arguments for parallel execution - fi_dict = self.fi.floris.as_dict() + fmodel_dict = self.fmodel.core.as_dict() wind_condition_id_splits = np.array_split( - np.arange(self.fi.floris.flow_field.n_findex), + np.arange(self.fmodel.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: - fi_dict_split = copy.deepcopy(fi_dict) - wind_directions = self.fi.floris.flow_field.wind_directions[wc_id_split] - wind_speeds = self.fi.floris.flow_field.wind_speeds[wc_id_split] - turbulence_intensities = self.fi.floris.flow_field.turbulence_intensities[wc_id_split] + fmodel_dict_split = copy.deepcopy(fmodel_dict) + wind_directions = self.fmodel.core.flow_field.wind_directions[wc_id_split] + wind_speeds = self.fmodel.core.flow_field.wind_speeds[wc_id_split] + turbulence_intensities = self.fmodel.core.flow_field.turbulence_intensities[wc_id_split] yaw_angles_subset = yaw_angles[wc_id_split[0]:wc_id_split[-1]+1, :] - fi_dict_split["flow_field"]["wind_directions"] = wind_directions - fi_dict_split["flow_field"]["wind_speeds"] = wind_speeds - fi_dict_split["flow_field"]["turbulence_intensities"] = turbulence_intensities + 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 - if isinstance(self.fi, FlorisInterface): - fi_information = (fi_dict_split, None, None) + if isinstance(self.fmodel, FlorisModel): + fmodel_information = (fmodel_dict_split, None, None) else: - fi_information = ( - fi_dict_split, - self.fi.fi.het_map, - self.fi.unc_pmfs, - self.fi.fix_yaw_in_relative_frame + fmodel_information = ( + fmodel_dict_split, + self.fmodel.fmodel.het_map, + self.fmodel.unc_pmfs, + self.fmodel.fix_yaw_in_relative_frame ) - multiargs.append((fi_information, yaw_angles_subset)) + multiargs.append((fmodel_information, yaw_angles_subset)) return multiargs @@ -266,14 +266,14 @@ def _postprocessing(self, output): # Optionally, also merge flow field dictionaries from individual floris solutions if self.propagate_flowfield_from_workers: - self.floris = self.fi.floris # Refresh static copy of underlying floris class - # self.floris.flow_field.u_initial = self._merge_subsets("u_initial", flowfield_subsets) - # self.floris.flow_field.v_initial = self._merge_subsets("v_initial", flowfield_subsets) - # self.floris.flow_field.w_initial = self._merge_subsets("w_initial", flowfield_subsets) - self.floris.flow_field.u = self._merge_subsets("u", flowfield_subsets) - self.floris.flow_field.v = self._merge_subsets("v", flowfield_subsets) - self.floris.flow_field.w = self._merge_subsets("w", flowfield_subsets) - self.floris.flow_field.turbulence_intensity_field = self._merge_subsets( + self.core = self.fmodel.core # Refresh static copy of underlying floris class + # self.core.flow_field.u_initial = self._merge_subsets("u_initial", flowfield_subsets) + # self.core.flow_field.v_initial = self._merge_subsets("v_initial", flowfield_subsets) + # self.core.flow_field.w_initial = self._merge_subsets("w_initial", flowfield_subsets) + self.core.flow_field.u = self._merge_subsets("u", flowfield_subsets) + self.core.flow_field.v = self._merge_subsets("v", flowfield_subsets) + self.core.flow_field.w = self._merge_subsets("w", flowfield_subsets) + self.core.flow_field.turbulence_intensity_field = self._merge_subsets( "turbulence_intensity_field", flowfield_subsets ) @@ -329,8 +329,8 @@ def get_farm_power(self, yaw_angles=None, turbine_weights=None): # Default to equal weighing of all turbines when turbine_weights is None turbine_weights = np.ones( ( - self.fi.floris.flow_field.n_findex, - self.fi.floris.farm.n_turbines + self.fmodel.core.flow_field.n_findex, + self.fmodel.core.farm.n_turbines ) ) elif len(np.shape(turbine_weights)) == 1: @@ -338,7 +338,7 @@ def get_farm_power(self, yaw_angles=None, turbine_weights=None): turbine_weights = np.tile( turbine_weights, ( - self.fi.floris.flow_field.n_findex, + self.fmodel.core.flow_field.n_findex, 1 ) ) @@ -407,7 +407,7 @@ def get_farm_AEP( # If no_wake==True, ignore parallelization because it's fast enough if no_wake: - return self.fi.get_farm_AEP( + return self.fmodel.get_farm_AEP( freq=freq, cut_in_wind_speed=cut_in_wind_speed, cut_out_wind_speed=cut_out_wind_speed, @@ -418,8 +418,8 @@ def get_farm_AEP( # Verify dimensions of the variable "freq" if not ( - (np.shape(freq)[0] == self.fi.floris.flow_field.n_wind_directions) - & (np.shape(freq)[1] == self.fi.floris.flow_field.n_wind_speeds) + (np.shape(freq)[0] == self.fmodel.core.flow_field.n_wind_directions) + & (np.shape(freq)[1] == self.fmodel.core.flow_field.n_wind_speeds) & (len(np.shape(freq)) == 2) ): raise UserWarning( @@ -435,13 +435,13 @@ def get_farm_AEP( # Copy the full wind speed array from the floris object and initialize # the the farm_power variable as an empty array. - wind_speeds = np.array(self.fi.floris.flow_field.wind_speeds, copy=True) - wind_directions = np.array(self.fi.floris.flow_field.wind_directions, copy=True) + wind_speeds = np.array(self.fmodel.core.flow_field.wind_speeds, copy=True) + wind_directions = np.array(self.fmodel.core.flow_field.wind_directions, copy=True) turbulence_intensities = np.array( - self.fi.floris.flow_field.turbulence_intensities, + self.fmodel.core.flow_field.turbulence_intensities, copy=True, ) - farm_power = np.zeros((self.fi.floris.flow_field.n_wind_directions, len(wind_speeds))) + farm_power = np.zeros((self.fmodel.core.flow_field.n_wind_directions, len(wind_speeds))) # Determine which wind speeds we must evaluate in floris conditions_to_evaluate = wind_speeds >= cut_in_wind_speed @@ -456,7 +456,7 @@ def get_farm_AEP( yaw_angles_subset = None if yaw_angles is not None: yaw_angles_subset = yaw_angles[:, conditions_to_evaluate] - self.fi.set( + self.fmodel.set( wind_directions=wind_direction_subset, wind_speeds=wind_speeds_subset, turbulence_intensities=turbulence_intensities_subset, @@ -469,7 +469,7 @@ def get_farm_AEP( aep = np.sum(np.multiply(freq, farm_power) * 365 * 24) # Reset the FLORIS object to the full wind speed array - self.fi.set( + self.fmodel.set( wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities_subset, @@ -549,12 +549,12 @@ def optimize_yaw_angles( @property def layout_x(self): - return self.fi.layout_x + return self.fmodel.layout_x @property def layout_y(self): - return self.fi.layout_y + return self.fmodel.layout_y # @property # def floris(self): - # return self.fi.floris + # return self.fmodel.core diff --git a/floris/simulation/wake_combination/__init__.py b/floris/simulation/wake_combination/__init__.py deleted file mode 100644 index 9d8c70ea8..000000000 --- a/floris/simulation/wake_combination/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ - -from floris.simulation.wake_combination.fls import FLS -from floris.simulation.wake_combination.max import MAX -from floris.simulation.wake_combination.sosfs import SOSFS diff --git a/floris/simulation/wake_deflection/__init__.py b/floris/simulation/wake_deflection/__init__.py deleted file mode 100644 index 9c5937913..000000000 --- a/floris/simulation/wake_deflection/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ - -from floris.simulation.wake_deflection.empirical_gauss import EmpiricalGaussVelocityDeflection -from floris.simulation.wake_deflection.gauss import GaussVelocityDeflection -from floris.simulation.wake_deflection.jimenez import JimenezVelocityDeflection -from floris.simulation.wake_deflection.none import NoneVelocityDeflection diff --git a/floris/simulation/wake_turbulence/__init__.py b/floris/simulation/wake_turbulence/__init__.py deleted file mode 100644 index 51bee5f74..000000000 --- a/floris/simulation/wake_turbulence/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ - -from floris.simulation.wake_turbulence.crespo_hernandez import CrespoHernandez -from floris.simulation.wake_turbulence.none import NoneWakeTurbulence -from floris.simulation.wake_turbulence.wake_induced_mixing import WakeInducedMixing diff --git a/floris/simulation/wake_velocity/__init__.py b/floris/simulation/wake_velocity/__init__.py deleted file mode 100644 index f0d3b4c99..000000000 --- a/floris/simulation/wake_velocity/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ - -from floris.simulation.wake_velocity.cumulative_gauss_curl import CumulativeGaussCurlVelocityDeficit -from floris.simulation.wake_velocity.empirical_gauss import EmpiricalGaussVelocityDeficit -from floris.simulation.wake_velocity.gauss import GaussVelocityDeficit -from floris.simulation.wake_velocity.jensen import JensenVelocityDeficit -from floris.simulation.wake_velocity.none import NoneVelocityDeficit -from floris.simulation.wake_velocity.turbopark import TurbOParkVelocityDeficit diff --git a/floris/tools/__init__.py b/floris/tools/__init__.py deleted file mode 100644 index 94160d697..000000000 --- a/floris/tools/__init__.py +++ /dev/null @@ -1,48 +0,0 @@ - -""" -The :py:obj:`floris.tools` package contains the modules used to drive -FLORIS simulations and perform studies in various areas of research and -analysis. - -All modules can be imported with - - >>> import floris.tools - -The ``__init__.py`` file enables the import of all modules in this -package so any additional modules should be included there. - -Examples: - >>> import floris.tools - - >>> dir(floris.tools) - ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', - '__name__', '__package__', '__path__', '__spec__', 'cut_plane', - 'floris_interface', - 'layout_visualization', 'optimization', 'plotting', 'power_rose', - 'visualization'] -""" - -from .floris_interface import FlorisInterface -from .flow_visualization import ( - plot_rotor_values, - visualize_cut_plane, - visualize_quiver, -) -from .parallel_computing_interface import ParallelComputingInterface -from .uncertainty_interface import UncertaintyInterface -from .wind_data import ( - TimeSeries, - WindRose, - WindTIRose, -) - - -# from floris.tools import ( -# cut_plane, -# floris_interface, -# layout_visualization, -# optimization, -# plotting, -# power_rose, -# visualization, -# ) diff --git a/floris/turbine_library/turbine_previewer.py b/floris/turbine_library/turbine_previewer.py index 2324b51e2..4d18478a2 100644 --- a/floris/turbine_library/turbine_previewer.py +++ b/floris/turbine_library/turbine_previewer.py @@ -8,7 +8,7 @@ import numpy as np from attrs import define, field -from floris.simulation.turbine.turbine import ( +from floris.core.turbine.turbine import ( power, thrust_coefficient, Turbine, diff --git a/floris/tools/uncertainty_interface.py b/floris/uncertainty_interface.py similarity index 92% rename from floris/tools/uncertainty_interface.py rename to floris/uncertainty_interface.py index f2be5c02c..9a2acab4d 100644 --- a/floris/tools/uncertainty_interface.py +++ b/floris/uncertainty_interface.py @@ -4,21 +4,22 @@ import numpy as np +from floris import FlorisModel from floris.logging_manager import LoggingManager -from floris.tools import FlorisInterface -from floris.tools.wind_data import WindDataBase from floris.type_dec import ( floris_array_converter, NDArrayBool, NDArrayFloat, ) +from floris.utilities import wrap_360 +from floris.wind_data import WindDataBase class UncertaintyInterface(LoggingManager): """ An interface for handling uncertainty in wind farm simulations. - This class contains a FlorisInterface object and adds functionality to handle + This class contains a FlorisModel object and adds functionality to handle uncertainty in wind direction. Args: @@ -28,7 +29,7 @@ class UncertaintyInterface(LoggingManager): - **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.floris.Floris` for more details. + - **logging**: See `floris.core.Core` for more details. wd_resolution (float, optional): The resolution of wind direction, in degrees. Defaults to 1.0. ws_resolution (float, optional): The resolution of wind speed, in m/s. Defaults to 1.0. @@ -64,7 +65,7 @@ def __init__( - **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.floris.Floris` for more details. + - **logging**: See `floris.simulation.core.Core` for more details. 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. @@ -98,14 +99,14 @@ def __init__( # Get the weights self.weights = self._get_weights(self.wd_std, self.wd_sample_points) - # Instantiate the un-expanded FlorisInterface - self.fi_unexpanded = FlorisInterface(configuration) + # Instantiate the un-expanded FlorisModel + self.fmodel_unexpanded = FlorisModel(configuration) # Call set at this point with no arguments so ready to run self.set() - # Instantiate the expanded FlorisInterface - # self.floris_interface = FlorisInterface(configuration) + # Instantiate the expanded FlorisModel + # self.core_interface = FlorisModel(configuration) def set( @@ -121,7 +122,7 @@ def set( **kwargs: The wind farm conditions to set. """ # Call the nominal set function - self.fi_unexpanded.set( + self.fmodel_unexpanded.set( **kwargs ) @@ -138,13 +139,13 @@ def _set_uncertain( # Grab the unexpanded values of all arrays # These original dimensions are what is returned - self.wind_directions_unexpanded = self.fi_unexpanded.floris.flow_field.wind_directions - self.wind_speeds_unexpanded = self.fi_unexpanded.floris.flow_field.wind_speeds + self.wind_directions_unexpanded = self.fmodel_unexpanded.core.flow_field.wind_directions + self.wind_speeds_unexpanded = self.fmodel_unexpanded.core.flow_field.wind_speeds self.turbulence_intensities_unexpanded = ( - self.fi_unexpanded.floris.flow_field.turbulence_intensities + self.fmodel_unexpanded.core.flow_field.turbulence_intensities ) - self.yaw_angles_unexpanded = self.fi_unexpanded.floris.farm.yaw_angles - self.power_setpoints_unexpanded = self.fi_unexpanded.floris.farm.power_setpoints + self.yaw_angles_unexpanded = self.fmodel_unexpanded.core.farm.yaw_angles + self.power_setpoints_unexpanded = self.fmodel_unexpanded.core.farm.power_setpoints self.n_unexpanded = len(self.wind_directions_unexpanded) # Combine into the complete unexpanded_inputs @@ -186,44 +187,44 @@ def _set_uncertain( print(f"Expanded num rows: {self.n_expanded}") print(f"Unique num rows: {self.n_unique}") - # Initiate the expanded FlorisInterface - self.fi_expanded = self.fi_unexpanded.copy() + # Initiate the expanded FlorisModel + self.fmodel_expanded = self.fmodel_unexpanded.copy() # Now set the underlying wd/ws/ti/yaw/setpoint to check only the unique conditions - self.fi_expanded.set( + self.fmodel_expanded.set( wind_directions=self.unique_inputs[:, 0], wind_speeds=self.unique_inputs[:, 1], turbulence_intensities=self.unique_inputs[:, 2], - yaw_angles=self.unique_inputs[:, 3 : 3 + self.fi_unexpanded.floris.farm.n_turbines], - power_setpoints=self.unique_inputs[:, 3 + self.fi_unexpanded.floris.farm.n_turbines:] + yaw_angles=self.unique_inputs[:, 3 : 3 + self.fmodel_unexpanded.core.farm.n_turbines], + power_setpoints=self.unique_inputs[:, 3 + self.fmodel_unexpanded.core.farm.n_turbines:] ) def run(self): """ - Run the simulation in the underlying FlorisInterface object. + Run the simulation in the underlying FlorisModel object. """ - self.fi_expanded.run() + self.fmodel_expanded.run() def run_no_wake(self): """ - Run the simulation in the underlying FlorisInterface object without wakes. + Run the simulation in the underlying FlorisModel object without wakes. """ - self.fi_expanded.run_no_wake() + self.fmodel_expanded.run_no_wake() def reset_operation(self): """ - Reset the operation of the underlying FlorisInterface object. + Reset the operation of the underlying FlorisModel object. """ - self.fi_unexpanded.set( + self.fmodel_unexpanded.set( wind_directions=self.wind_directions_unexpanded, wind_speeds=self.wind_speeds_unexpanded, turbulence_intensities=self.turbulence_intensities_unexpanded, ) - self.fi_unexpanded.reset_operation() + self.fmodel_unexpanded.reset_operation() - # Calling set_uncertain again to reset the expanded FlorisInterface + # Calling set_uncertain again to reset the expanded FlorisModel self._set_uncertain() def get_turbine_powers(self): @@ -238,7 +239,7 @@ def get_turbine_powers(self): """ # First call the underlying function - unique_turbine_powers = self.fi_expanded.get_turbine_powers() + unique_turbine_powers = self.fmodel_expanded.get_turbine_powers() # Expand back to the expanded value expanded_turbine_powers = unique_turbine_powers[self.map_to_expanded_inputs] @@ -249,7 +250,7 @@ def get_turbine_powers(self): # Reshape expanded_turbine_powers into blocks blocks = np.reshape( expanded_turbine_powers, - (self.n_unexpanded, self.n_sample_points, self.fi_unexpanded.floris.farm.n_turbines), + (self.n_unexpanded, self.n_sample_points, self.fmodel_unexpanded.core.farm.n_turbines), order="F", ) @@ -292,7 +293,7 @@ def get_farm_power( turbine_weights = np.ones( ( self.n_unexpanded, - self.fi_unexpanded.floris.farm.n_turbines, + self.fmodel_unexpanded.core.farm.n_turbines, ) ) elif len(np.shape(turbine_weights)) == 1: @@ -636,7 +637,7 @@ def layout_x(self): Returns: np.array: Wind turbine x-coordinate. """ - return self.floris_interface.floris.farm.layout_x + return self.core_interface.core.farm.layout_x @property def layout_y(self): @@ -646,4 +647,4 @@ def layout_y(self): Returns: np.array: Wind turbine y-coordinate. """ - return self.floris_interface.floris.farm.layout_y + return self.core_interface.core.farm.layout_y diff --git a/floris/tools/wind_data.py b/floris/wind_data.py similarity index 99% rename from floris/tools/wind_data.py rename to floris/wind_data.py index 8f2dd78df..ab202e670 100644 --- a/floris/tools/wind_data.py +++ b/floris/wind_data.py @@ -28,7 +28,7 @@ def unpack(self): def unpack_for_reinitialize(self): """ - Return only the variables need for FlorisInterface.reinitialize + Return only the variables need for FlorisModel.reinitialize """ ( wind_directions_unpack, diff --git a/profiling/profiling.py b/profiling/profiling.py index 272f75730..a4fcc769d 100644 --- a/profiling/profiling.py +++ b/profiling/profiling.py @@ -9,12 +9,12 @@ from conftest import SampleInputs -from floris.simulation import Floris +from floris.core import Core def run_floris(): - floris = Floris.from_file("examples/example_input.yaml") - return floris + core = Core.from_file("examples/example_input.yaml") + return core if __name__=="__main__": # if len(sys.argv) > 1: @@ -30,24 +30,25 @@ def run_floris(): sample_inputs = SampleInputs() - sample_inputs.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs.floris["wake"]["model_strings"]["deflection_model"] = "gauss" - sample_inputs.floris["wake"]["enable_secondary_steering"] = True - sample_inputs.floris["wake"]["enable_yaw_added_recovery"] = True - sample_inputs.floris["wake"]["enable_transverse_velocities"] = True + sample_inputs.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs.core["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs.core["wake"]["enable_secondary_steering"] = True + sample_inputs.core["wake"]["enable_yaw_added_recovery"] = True + sample_inputs.core["wake"]["enable_transverse_velocities"] = True N_TURBINES = 100 N_FINDEX = 72 * 25 # Size of a characteristic wind rose - TURBINE_DIAMETER = sample_inputs.floris["farm"]["turbine_type"][0]["rotor_diameter"] - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * i for i in range(N_TURBINES)] - sample_inputs.floris["farm"]["layout_y"] = [0.0 for i in range(N_TURBINES)] + TURBINE_DIAMETER = sample_inputs.core["farm"]["turbine_type"][0]["rotor_diameter"] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * i for i in range(N_TURBINES)] + sample_inputs.core["farm"]["layout_y"] = [0.0 for i in range(N_TURBINES)] - sample_inputs.floris["flow_field"]["wind_directions"] = N_FINDEX * [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = N_FINDEX * [8.0] + sample_inputs.core["flow_field"]["wind_directions"] = N_FINDEX * [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = N_FINDEX * [8.0] + sample_inputs.core["flow_field"]["turbulence_intensities"] = N_FINDEX * [0.06] N = 1 for i in range(N): - floris = Floris.from_dict(copy.deepcopy(sample_inputs.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(sample_inputs.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() diff --git a/profiling/quality_metrics.py b/profiling/quality_metrics.py index 27d7c5aca..142480550 100644 --- a/profiling/quality_metrics.py +++ b/profiling/quality_metrics.py @@ -6,7 +6,7 @@ import numpy as np from linux_perf import perf -from floris.simulation import Floris +from floris.core import Core wd_grid, ws_grid = np.meshgrid( @@ -33,9 +33,9 @@ def run_floris(input_dict): try: start = time.perf_counter() - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() end = time.perf_counter() return end - start except KeyError: @@ -57,43 +57,43 @@ def time_profile(input_dict): def test_time_jensen_jimenez(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "jensen" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "jimenez" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "jensen" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "jimenez" return time_profile(sample_inputs_fixture) def test_time_gauss(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" return time_profile(sample_inputs_fixture) def test_time_gch(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True return time_profile(sample_inputs_fixture) def test_time_cumulative(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "cc" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "cc" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" return time_profile(sample_inputs_fixture) def memory_profile(input_dict): # Run once to initialize Python and memory - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() with perf(): for i in range(N_ITERATIONS): - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() print( "Size of one data array: " @@ -102,8 +102,8 @@ def memory_profile(input_dict): def test_mem_jensen_jimenez(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "jensen" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "jimenez" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "jensen" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "jimenez" memory_profile(sample_inputs_fixture) @@ -113,11 +113,11 @@ def test_mem_jensen_jimenez(sample_inputs_fixture): from conftest import SampleInputs sample_inputs = SampleInputs() - sample_inputs.floris["farm"]["layout_x"] = X_COORDS - sample_inputs.floris["farm"]["layout_y"] = Y_COORDS - sample_inputs.floris["flow_field"]["wind_directions"] = WIND_DIRECTIONS - sample_inputs.floris["flow_field"]["wind_speeds"] = WIND_SPEEDS - sample_inputs.floris["flow_field"]["turbulence_intensities"] = TURBULENCE_INTENSITIES + sample_inputs.core["farm"]["layout_x"] = X_COORDS + sample_inputs.core["farm"]["layout_y"] = Y_COORDS + sample_inputs.core["flow_field"]["wind_directions"] = WIND_DIRECTIONS + sample_inputs.core["flow_field"]["wind_speeds"] = WIND_SPEEDS + sample_inputs.core["flow_field"]["turbulence_intensities"] = TURBULENCE_INTENSITIES print() print("### Memory profiling") diff --git a/profiling/serial_vectorize.py b/profiling/serial_vectorize.py index 7c6c33207..fb66a1652 100644 --- a/profiling/serial_vectorize.py +++ b/profiling/serial_vectorize.py @@ -11,7 +11,7 @@ def time_vec(input_dict): start = time.time() - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) end = time.time() init_time = end - start @@ -29,11 +29,11 @@ def time_serial(input_dict, wd, ws): for i, (d, s) in enumerate(zip(wd, ws)): - input_dict.floris["flow_field"]["wind_directions"] = [d] - input_dict.floris["flow_field"]["wind_speeds"] = [s] + input_dict.core["flow_field"]["wind_directions"] = [d] + input_dict.core["flow_field"]["wind_speeds"] = [s] start = time.time() - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) end = time.time() init_times[i] = end - start @@ -48,9 +48,9 @@ def time_serial(input_dict, wd, ws): plt.figure() sample_inputs = SampleInputs() - sample_inputs.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = [8.0] - TURBINE_DIAMETER = sample_inputs.floris["turbine"]["rotor_diameter"] + sample_inputs.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = [8.0] + TURBINE_DIAMETER = sample_inputs.core["turbine"]["rotor_diameter"] N = 5 simulation_size = np.arange(N) @@ -61,8 +61,8 @@ def time_serial(input_dict, wd, ws): vectorize_scaling_inputs = copy.deepcopy(sample_inputs) factor = (i+1) * 50 - vectorize_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] - vectorize_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + vectorize_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] + vectorize_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] vectorize_init[i], vectorize_calc[i] = time_vec(copy.deepcopy(vectorize_scaling_inputs)) print("vectorize", i, vectorize_calc[i]) @@ -90,16 +90,16 @@ def time_serial(input_dict, wd, ws): # More than 1 turbine n_turbines = 10 - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] - sample_inputs.floris["farm"]["layout_y"] = n_turbines * [0.0] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] + sample_inputs.core["farm"]["layout_y"] = n_turbines * [0.0] vectorize_init, vectorize_calc = np.zeros(N), np.zeros(N) for i in range(N): vectorize_scaling_inputs = copy.deepcopy(sample_inputs) factor = (i+1) * 50 - vectorize_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] - vectorize_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] + vectorize_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] + vectorize_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] vectorize_init[i], vectorize_calc[i] = time_vec(copy.deepcopy(vectorize_scaling_inputs)) print("vectorize", i, vectorize_calc[i]) diff --git a/profiling/timing.py b/profiling/timing.py index 3083403da..b03cd23db 100644 --- a/profiling/timing.py +++ b/profiling/timing.py @@ -11,19 +11,19 @@ def time_profile(input_dict): - floris = Floris.from_dict(input_dict.floris) + floris = Floris.from_dict(input_dict.core) start = time.perf_counter() floris.steady_state_atmospheric_condition() end = time.perf_counter() return end - start def internal_probe(input_dict): - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) internal_quantity = floris.steady_state_atmospheric_condition() return internal_quantity def memory_profile(input_dict): - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) mem_usage = memory_profiler.memory_usage( (floris.steady_state_atmospheric_condition, (), {}), max_usage=True @@ -32,10 +32,10 @@ def memory_profile(input_dict): if __name__=="__main__": sample_inputs = SampleInputs() - TURBINE_DIAMETER = sample_inputs.floris["turbine"]["rotor_diameter"] + TURBINE_DIAMETER = sample_inputs.core["turbine"]["rotor_diameter"] # Use Gauss models - sample_inputs.floris["wake"]["model_strings"] = { + sample_inputs.core["wake"]["model_strings"] = { "velocity_model": "gauss", "deflection_model": "gauss", "combination_model": None, @@ -51,8 +51,8 @@ def memory_profile(input_dict): # wind_direction_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_direction_scaling_inputs.floris["flow_field"]["wind_directions"] = factor * [270.0] - # wind_direction_scaling_inputs.floris["flow_field"]["wind_speeds"] = [8.0] + # wind_direction_scaling_inputs.core["flow_field"]["wind_directions"] = factor * [270.0] + # wind_direction_scaling_inputs.core["flow_field"]["wind_speeds"] = [8.0] # wd_calc_time[i] = time_profile(copy.deepcopy(wind_direction_scaling_inputs)) # wd_size[i] = factor @@ -64,8 +64,8 @@ def memory_profile(input_dict): # wind_speed_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_speed_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] - # wind_speed_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + # wind_speed_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] + # wind_speed_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] # ws_calc_time[i] = time_profile(copy.deepcopy(wind_speed_scaling_inputs)) # ws_size[i] = factor @@ -77,11 +77,11 @@ def memory_profile(input_dict): # turbine_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 3 - # turbine_scaling_inputs.floris["farm"]["layout_x"] = [ + # turbine_scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # turbine_scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # turbine_scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # turb_calc_time[i] = time_profile(copy.deepcopy(turbine_scaling_inputs)) # turb_size[i] = factor @@ -92,14 +92,14 @@ def memory_profile(input_dict): # scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(5): # factor = (i+1) * 2 - # scaling_inputs.floris["farm"]["layout_x"] = [ + # scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # factor = (i+1) * 20 - # scaling_inputs.floris["flow_field"]["wind_directions"] = factor * [270.0] - # scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + # scaling_inputs.core["flow_field"]["wind_directions"] = factor * [270.0] + # scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] # internal_quantity[i] = time_profile(scaling_inputs) # print("n turbine", i, internal_quantity[i]) @@ -118,7 +118,7 @@ def memory_profile(input_dict): n_wind_directions = 1 n_wind_speeds = 1 n_turbines = 3 - sample_inputs.floris["wake"]["model_strings"] = { + sample_inputs.core["wake"]["model_strings"] = { # "velocity_model": "jensen", # "deflection_model": "jimenez", "velocity_model": "cc", @@ -126,18 +126,18 @@ def memory_profile(input_dict): "combination_model": None, "turbulence_model": None, } - sample_inputs.floris["solver"] = { + sample_inputs.core["solver"] = { "type": "turbine_grid", "turbine_grid_points": 5 } - # sample_inputs.floris["wake"]["enable_transverse_velocities"] = False - # sample_inputs.floris["wake"]["enable_secondary_steering"] = False - # sample_inputs.floris["wake"]["enable_yaw_added_recovery"] = False - sample_inputs.floris["flow_field"]["wind_directions"] = n_wind_directions * [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = n_wind_speeds * [8.0] - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] - sample_inputs.floris["farm"]["layout_y"] = n_turbines * [0.0] + # sample_inputs.core["wake"]["enable_transverse_velocities"] = False + # sample_inputs.core["wake"]["enable_secondary_steering"] = False + # sample_inputs.core["wake"]["enable_yaw_added_recovery"] = False + sample_inputs.core["flow_field"]["wind_directions"] = n_wind_directions * [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = n_wind_speeds * [8.0] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] + sample_inputs.core["farm"]["layout_y"] = n_turbines * [0.0] N = 1 times = np.zeros(N) @@ -158,8 +158,8 @@ def memory_profile(input_dict): # wind_direction_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_direction_scaling_inputs.floris["farm"]["wind_directions"] = factor * [270.0] - # wind_direction_scaling_inputs.floris["farm"]["wind_speeds"] = [8.0] + # wind_direction_scaling_inputs.core["farm"]["wind_directions"] = factor * [270.0] + # wind_direction_scaling_inputs.core["farm"]["wind_speeds"] = [8.0] # wd_space[i] = memory_profile(wind_direction_scaling_inputs) # print("wind direction", i, wd_space[i]) @@ -169,8 +169,8 @@ def memory_profile(input_dict): # wind_speed_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_speed_scaling_inputs.floris["farm"]["wind_directions"] = [270.0] - # wind_speed_scaling_inputs.floris["farm"]["wind_speeds"] = factor * [8.0] + # wind_speed_scaling_inputs.core["farm"]["wind_directions"] = [270.0] + # wind_speed_scaling_inputs.core["farm"]["wind_speeds"] = factor * [8.0] # ws_space[i] = memory_profile(wind_speed_scaling_inputs) # print("wind speed", i, ws_space[i]) @@ -180,11 +180,11 @@ def memory_profile(input_dict): # turbine_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # turbine_scaling_inputs.floris["farm"]["layout_x"] = [ + # turbine_scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # turbine_scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # turbine_scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # turb_space[i] = memory_profile(turbine_scaling_inputs) # print("n turbine", turb_space[i]) diff --git a/pyproject.toml b/pyproject.toml index 5610ba9f3..330c5a2d8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -116,18 +116,18 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" [tool.ruff.per-file-ignores] # F841 unused-variable: ignore since this file uses numexpr and many variables look unused -"floris/simulation/wake_deflection/jimenez.py" = ["F841"] -"floris/simulation/wake_turbulence/crespo_hernandez.py" = ["F841"] -"floris/simulation/wake_deflection/gauss.py" = ["F841"] -"floris/simulation/wake_velocity/jensen.py" = ["F841"] -"floris/simulation/wake_velocity/gauss.py" = ["F841"] -"floris/simulation/wake_velocity/empirical_gauss.py" = ["F841"] +"floris/core/wake_deflection/jimenez.py" = ["F841"] +"floris/core/wake_turbulence/crespo_hernandez.py" = ["F841"] +"floris/core/wake_deflection/gauss.py" = ["F841"] +"floris/core/wake_velocity/jensen.py" = ["F841"] +"floris/core/wake_velocity/gauss.py" = ["F841"] +"floris/core/wake_velocity/empirical_gauss.py" = ["F841"] # Ignore `F401` (import violations) in all `__init__.py` files, and in `path/to/file.py`. "__init__.py" = ["F401"] # I001 unsorted-imports: ignore because the import order is meaningful to navigate # import dependencies -"floris/simulation/__init__.py" = ["I001"] +"floris/core/__init__.py" = ["I001"] [tool.ruff.isort] combine-as-imports = true diff --git a/setup.py b/setup.py index a50eb738e..54da3219c 100644 --- a/setup.py +++ b/setup.py @@ -67,7 +67,7 @@ url=URL, packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]), package_data={ - 'floris': ['turbine_library/*.yaml', 'simulation/wake_velocity/turbopark_lookup_table.mat'] + 'floris': ['turbine_library/*.yaml', 'core/wake_velocity/turbopark_lookup_table.mat'] }, install_requires=REQUIRED, extras_require=EXTRAS, diff --git a/tests/base_unit_test.py b/tests/base_unit_test.py index 89a608041..fadae3523 100644 --- a/tests/base_unit_test.py +++ b/tests/base_unit_test.py @@ -3,7 +3,7 @@ from attr import define, field from attrs.exceptions import FrozenAttributeError -from floris.simulation import BaseClass, BaseModel +from floris.core import BaseClass, BaseModel @define diff --git a/tests/conftest.py b/tests/conftest.py index a8dd8fabb..70e1d2ca9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -6,8 +6,8 @@ import numpy as np import pytest -from floris.simulation import ( - Floris, +from floris.core import ( + Core, FlowField, FlowFieldGrid, PointsGrid, @@ -191,7 +191,7 @@ def points_grid_fixture(sample_inputs_fixture) -> PointsGrid: @pytest.fixture def floris_fixture(): sample_inputs = SampleInputs() - return Floris(sample_inputs.floris) + return Core(sample_inputs.core) @pytest.fixture def sample_inputs_fixture(): @@ -510,7 +510,7 @@ def __init__(self): "enable_transverse_velocities": False, } - self.floris = { + self.core = { "farm": self.farm, "flow_field": self.flow_field, "wake": self.wake, diff --git a/tests/floris_unit_test.py b/tests/core_unit_test.py similarity index 58% rename from tests/floris_unit_test.py rename to tests/core_unit_test.py index ef7d140e5..5e9108354 100644 --- a/tests/floris_unit_test.py +++ b/tests/core_unit_test.py @@ -3,9 +3,9 @@ import yaml -from floris.simulation import ( +from floris.core import ( + Core, Farm, - Floris, FlowField, TurbineGrid, WakeModelManager, @@ -18,29 +18,29 @@ def test_read_yaml(): - fi = Floris.from_file(YAML_INPUT) - assert isinstance(fi, Floris) + fmodel = Core.from_file(YAML_INPUT) + assert isinstance(fmodel, Core) def test_read_dict(): - fi = Floris.from_dict(DICT_INPUT) - assert isinstance(fi, Floris) + fmodel = Core.from_dict(DICT_INPUT) + assert isinstance(fmodel, Core) def test_init(): - fi = Floris.from_dict(DICT_INPUT) - assert isinstance(fi.farm, Farm) - assert isinstance(fi.wake, WakeModelManager) - assert isinstance(fi.flow_field, FlowField) + fmodel = Core.from_dict(DICT_INPUT) + assert isinstance(fmodel.farm, Farm) + assert isinstance(fmodel.wake, WakeModelManager) + assert isinstance(fmodel.flow_field, FlowField) def test_asdict(turbine_grid_fixture: TurbineGrid): - floris = Floris.from_dict(DICT_INPUT) + floris = Core.from_dict(DICT_INPUT) floris.flow_field.initialize_velocity_field(turbine_grid_fixture) dict1 = floris.as_dict() - new_floris = Floris.from_dict(dict1) + new_floris = Core.from_dict(dict1) new_floris.flow_field.initialize_velocity_field(turbine_grid_fixture) dict2 = new_floris.as_dict() diff --git a/tests/farm_unit_test.py b/tests/farm_unit_test.py index 767ba3c0b..38d2b91a7 100644 --- a/tests/farm_unit_test.py +++ b/tests/farm_unit_test.py @@ -5,7 +5,7 @@ import numpy as np import pytest -from floris.simulation import Farm +from floris.core import Farm from floris.utilities import load_yaml from tests.conftest import ( N_FINDEX, diff --git a/tests/floris_interface_integration_test.py b/tests/floris_model_integration_test.py similarity index 54% rename from tests/floris_interface_integration_test.py rename to tests/floris_model_integration_test.py index 18e973857..0ba63fa59 100644 --- a/tests/floris_interface_integration_test.py +++ b/tests/floris_model_integration_test.py @@ -4,8 +4,8 @@ import pytest import yaml -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT -from floris.tools.floris_interface import FlorisInterface +from floris import FlorisModel +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT TEST_DATA = Path(__file__).resolve().parent / "data" @@ -13,33 +13,33 @@ def test_read_yaml(): - fi = FlorisInterface(configuration=YAML_INPUT) - assert isinstance(fi, FlorisInterface) + fmodel = FlorisModel(configuration=YAML_INPUT) + assert isinstance(fmodel, FlorisModel) def test_assign_setpoints(): - fi = FlorisInterface(configuration=YAML_INPUT) - fi.set(layout_x=[0, 0], layout_y=[0, 1000]) + fmodel = FlorisModel(configuration=YAML_INPUT) + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) # Test setting yaw angles via a list, integers, numpy array - fi.set(yaw_angles=[[20.0, 30.0]]) - fi.set(yaw_angles=[[20, 30]]) - fi.set(yaw_angles=np.array([[20.0, 30.0]])) + fmodel.set(yaw_angles=[[20.0, 30.0]]) + fmodel.set(yaw_angles=[[20, 30]]) + fmodel.set(yaw_angles=np.array([[20.0, 30.0]])) # Test setting power setpoints in various ways - fi.set(power_setpoints=[[1e6, 2e6]]) - fi.set(power_setpoints=np.array([[1e6, 2e6]])) + fmodel.set(power_setpoints=[[1e6, 2e6]]) + fmodel.set(power_setpoints=np.array([[1e6, 2e6]])) # Disable turbines - fi.set(disable_turbines=[[True, False]]) - fi.set(disable_turbines=np.array([[True, False]])) + fmodel.set(disable_turbines=[[True, False]]) + fmodel.set(disable_turbines=np.array([[True, False]])) # Combination - fi.set(yaw_angles=[[0, 30]], power_setpoints=np.array([[1e6, None]])) + fmodel.set(yaw_angles=[[0, 30]], power_setpoints=np.array([[1e6, None]])) # power_setpoints and disable_turbines (disable_turbines overrides power_setpoints) - fi.set(power_setpoints=[[1e6, 2e6]], disable_turbines=[[True, False]]) - assert np.allclose(fi.floris.farm.power_setpoints, np.array([[0.001, 2e6]])) + fmodel.set(power_setpoints=[[1e6, 2e6]], disable_turbines=[[True, False]]) + assert np.allclose(fmodel.core.farm.power_setpoints, np.array([[0.001, 2e6]])) def test_set_run(): """ @@ -51,129 +51,131 @@ def test_set_run(): # In FLORIS v3.2, running calculate_wake twice incorrectly set the yaw angles when the # first time has non-zero yaw settings but the second run had all-zero yaw settings. # The test below asserts that the yaw angles are correctly set in subsequent calls to run. - fi = FlorisInterface(configuration=YAML_INPUT) - yaw_angles = 20 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(yaw_angles=yaw_angles) - fi.run() - assert fi.floris.farm.yaw_angles == yaw_angles + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + assert fmodel.core.farm.yaw_angles == yaw_angles - yaw_angles = np.zeros((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(yaw_angles=yaw_angles) - fi.run() - assert fi.floris.farm.yaw_angles == yaw_angles + yaw_angles = np.zeros((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + assert fmodel.core.farm.yaw_angles == yaw_angles # Verify making changes to the layout, wind speed, wind direction and # turbulence intensity both before and after running the calculation - fi.reset_operation() - fi.set( + fmodel.reset_operation() + fmodel.set( layout_x=[0, 0], layout_y=[0, 1000], wind_speeds=[8, 8], wind_directions=[270, 270], turbulence_intensities=[0.06, 0.06] ) - assert np.array_equal(fi.floris.farm.layout_x, np.array([0, 0])) - assert np.array_equal(fi.floris.farm.layout_y, np.array([0, 1000])) - assert np.array_equal(fi.floris.flow_field.wind_speeds, np.array([8, 8])) - assert np.array_equal(fi.floris.flow_field.wind_directions, np.array([270, 270])) + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) # Double check that nothing has changed after running the calculation - fi.run() - assert np.array_equal(fi.floris.farm.layout_x, np.array([0, 0])) - assert np.array_equal(fi.floris.farm.layout_y, np.array([0, 1000])) - assert np.array_equal(fi.floris.flow_field.wind_speeds, np.array([8, 8])) - assert np.array_equal(fi.floris.flow_field.wind_directions, np.array([270, 270])) + fmodel.run() + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) # Verify that changing wind shear doesn't change the other settings above - fi.set(wind_shear=0.1) - assert fi.floris.flow_field.wind_shear == 0.1 - assert np.array_equal(fi.floris.farm.layout_x, np.array([0, 0])) - assert np.array_equal(fi.floris.farm.layout_y, np.array([0, 1000])) - assert np.array_equal(fi.floris.flow_field.wind_speeds, np.array([8, 8])) - assert np.array_equal(fi.floris.flow_field.wind_directions, np.array([270, 270])) + fmodel.set(wind_shear=0.1) + assert fmodel.core.flow_field.wind_shear == 0.1 + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) # Verify that operation set-points are retained after changing other settings - yaw_angles = 20 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(yaw_angles=yaw_angles) - assert np.array_equal(fi.floris.farm.yaw_angles, yaw_angles) - fi.set() - assert np.array_equal(fi.floris.farm.yaw_angles, yaw_angles) - fi.set(wind_speeds=[10, 10]) - assert np.array_equal(fi.floris.farm.yaw_angles, yaw_angles) - power_setpoints = 1e6 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(power_setpoints=power_setpoints) - assert np.array_equal(fi.floris.farm.yaw_angles, yaw_angles) - assert np.array_equal(fi.floris.farm.power_setpoints, power_setpoints) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + fmodel.set() + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + fmodel.set(wind_speeds=[10, 10]) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + assert np.array_equal(fmodel.core.farm.power_setpoints, power_setpoints) # Test that setting power setpoints through the .set() function actually sets the # power setpoints in the floris object - fi.reset_operation() - power_setpoints = 1e6 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(power_setpoints=power_setpoints) - fi.run() - assert np.array_equal(fi.floris.farm.power_setpoints, power_setpoints) + fmodel.reset_operation() + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints) + fmodel.run() + assert np.array_equal(fmodel.core.farm.power_setpoints, power_setpoints) # Similar to above, any "None" set-points should be set to the default value power_setpoints = np.array([[1e6, None]]) - fi.set(layout_x=[0, 0], layout_y=[0, 1000], power_setpoints=power_setpoints) - fi.run() + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000], power_setpoints=power_setpoints) + fmodel.run() assert np.array_equal( - fi.floris.farm.power_setpoints, + fmodel.core.farm.power_setpoints, np.array([[power_setpoints[0, 0], POWER_SETPOINT_DEFAULT]]) ) def test_reset_operation(): # Calling the reset function should reset the power setpoints to the default values - fi = FlorisInterface(configuration=YAML_INPUT) - yaw_angles = 20 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - power_setpoints = 1e6 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(power_setpoints=power_setpoints, yaw_angles=yaw_angles) - fi.run() - fi.reset_operation() - assert fi.floris.farm.yaw_angles == np.zeros( - (fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines) + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints, yaw_angles=yaw_angles) + fmodel.run() + fmodel.reset_operation() + assert fmodel.core.farm.yaw_angles == np.zeros( + (fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines) ) - assert fi.floris.farm.power_setpoints == ( - POWER_SETPOINT_DEFAULT * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) + assert fmodel.core.farm.power_setpoints == ( + POWER_SETPOINT_DEFAULT * np.ones((fmodel.core.flow_field.n_findex, + fmodel.core.farm.n_turbines)) ) # Double check that running the calculate also doesn't change the operating set points - fi.run() - assert fi.floris.farm.yaw_angles == np.zeros( - (fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines) + fmodel.run() + assert fmodel.core.farm.yaw_angles == np.zeros( + (fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines) ) - assert fi.floris.farm.power_setpoints == ( - POWER_SETPOINT_DEFAULT * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) + assert fmodel.core.farm.power_setpoints == ( + POWER_SETPOINT_DEFAULT * np.ones((fmodel.core.flow_field.n_findex, + fmodel.core.farm.n_turbines)) ) def test_run_no_wake(): # In FLORIS v3.2, running calculate_no_wake twice incorrectly set the yaw angles when the first # time has non-zero yaw settings but the second run had all-zero yaw settings. The test below # asserts that the yaw angles are correctly set in subsequent calls to run_no_wake. - fi = FlorisInterface(configuration=YAML_INPUT) - yaw_angles = 20 * np.ones((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(yaw_angles=yaw_angles) - fi.run_no_wake() - assert fi.floris.farm.yaw_angles == yaw_angles + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run_no_wake() + assert fmodel.core.farm.yaw_angles == yaw_angles - yaw_angles = np.zeros((fi.floris.flow_field.n_findex, fi.floris.farm.n_turbines)) - fi.set(yaw_angles=yaw_angles) - fi.run_no_wake() - assert fi.floris.farm.yaw_angles == yaw_angles + yaw_angles = np.zeros((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run_no_wake() + assert fmodel.core.farm.yaw_angles == yaw_angles # With no wake and three turbines in a line, the power for all turbines with zero yaw # should be the same - fi.reset_operation() - fi.set(layout_x=[0, 200, 4000], layout_y=[0, 0, 0]) - fi.run_no_wake() - power_no_wake = fi.get_turbine_powers() + fmodel.reset_operation() + fmodel.set(layout_x=[0, 200, 4000], layout_y=[0, 0, 0]) + fmodel.run_no_wake() + power_no_wake = fmodel.get_turbine_powers() assert len(np.unique(power_no_wake)) == 1 def test_get_turbine_powers(): # Get turbine powers should return n_findex x n_turbine powers # Apply the same wind speed and direction multiple times and confirm all equal - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) wind_speeds = np.array([8.0, 8.0, 8.0]) wind_directions = np.array([270.0, 270.0, 270.0]) @@ -184,7 +186,7 @@ def test_get_turbine_powers(): layout_y = np.array([0, 1000]) n_turbines = len(layout_x) - fi.set( + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, turbulence_intensities=turbulence_intensities, @@ -192,16 +194,16 @@ def test_get_turbine_powers(): layout_y=layout_y, ) - fi.run() + fmodel.run() - turbine_powers = fi.get_turbine_powers() + turbine_powers = fmodel.get_turbine_powers() assert turbine_powers.shape[0] == n_findex assert turbine_powers.shape[1] == n_turbines assert turbine_powers[0, 0] == turbine_powers[1, 0] def test_get_farm_power(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) wind_speeds = np.array([8.0, 8.0, 8.0]) wind_directions = np.array([270.0, 270.0, 270.0]) @@ -212,7 +214,7 @@ def test_get_farm_power(): layout_y = np.array([0, 1000]) # n_turbines = len(layout_x) - fi.set( + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, turbulence_intensities=turbulence_intensities, @@ -220,10 +222,10 @@ def test_get_farm_power(): layout_y=layout_y, ) - fi.run() + fmodel.run() - turbine_powers = fi.get_turbine_powers() - farm_powers = fi.get_farm_power() + turbine_powers = fmodel.get_turbine_powers() + farm_powers = fmodel.get_farm_power() assert farm_powers.shape[0] == n_findex @@ -234,7 +236,7 @@ def test_get_farm_power(): # Test using weights to disable the second turbine turbine_weights = np.array([1.0, 0.0]) - farm_powers = fi.get_farm_power(turbine_weights=turbine_weights) + farm_powers = fmodel.get_farm_power(turbine_weights=turbine_weights) # Assert farm power is now equal to the 0th turbine since 1st is # disabled @@ -245,28 +247,28 @@ def test_get_farm_power(): # findex values turbine_weights = np.array([[1.0, 1.0], [1.0, 1.0], [1.0, 0.0]]) - farm_powers = fi.get_farm_power(turbine_weights=turbine_weights) + farm_powers = fmodel.get_farm_power(turbine_weights=turbine_weights) turbine_powers[-1, 1] = 0 farm_power_from_turbine = turbine_powers.sum(axis=1) np.testing.assert_almost_equal(farm_power_from_turbine, farm_powers) def test_disable_turbines(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) # Set to mixed turbine model with open( str( - fi.floris.as_dict()["farm"]["turbine_library_path"] - / (fi.floris.as_dict()["farm"]["turbine_type"][0] + ".yaml") + fmodel.core.as_dict()["farm"]["turbine_library_path"] + / (fmodel.core.as_dict()["farm"]["turbine_type"][0] + ".yaml") ) ) as t: turbine_type = yaml.safe_load(t) turbine_type["power_thrust_model"] = "mixed" - fi.set(turbine_type=[turbine_type]) + fmodel.set(turbine_type=[turbine_type]) # Init to n-findex = 2, n_turbines = 3 - fi.set( + fmodel.set( wind_speeds=np.array([8.,8.,]), wind_directions=np.array([270.,270.]), turbulence_intensities=np.array([0.06,0.06]), @@ -276,71 +278,71 @@ def test_disable_turbines(): # Confirm that using a disable value with wrong n_findex raises error with pytest.raises(ValueError): - fi.set(disable_turbines=np.zeros((10, 3), dtype=bool)) - fi.run() + fmodel.set(disable_turbines=np.zeros((10, 3), dtype=bool)) + fmodel.run() # Confirm that using a disable value with wrong n_turbines raises error with pytest.raises(ValueError): - fi.set(disable_turbines=np.zeros((2, 10), dtype=bool)) - fi.run() + fmodel.set(disable_turbines=np.zeros((2, 10), dtype=bool)) + fmodel.run() # Confirm that if all turbines are disabled, power is near 0 for all turbines - fi.set(disable_turbines=np.ones((2, 3), dtype=bool)) - fi.run() - turbines_powers = fi.get_turbine_powers() + fmodel.set(disable_turbines=np.ones((2, 3), dtype=bool)) + fmodel.run() + turbines_powers = fmodel.get_turbine_powers() np.testing.assert_allclose(turbines_powers, 0, atol=0.1) # Confirm the same for run_no_wake - fi.run_no_wake() - turbines_powers = fi.get_turbine_powers() + fmodel.run_no_wake() + turbines_powers = fmodel.get_turbine_powers() np.testing.assert_allclose(turbines_powers, 0, atol=0.1) # Confirm that if all disabled values set to false, equivalent to running normally - fi.reset_operation() - fi.run() - turbines_powers_normal = fi.get_turbine_powers() - fi.set(disable_turbines=np.zeros((2, 3), dtype=bool)) - fi.run() - turbines_powers_false_disable = fi.get_turbine_powers() + fmodel.reset_operation() + fmodel.run() + turbines_powers_normal = fmodel.get_turbine_powers() + fmodel.set(disable_turbines=np.zeros((2, 3), dtype=bool)) + fmodel.run() + turbines_powers_false_disable = fmodel.get_turbine_powers() np.testing.assert_allclose(turbines_powers_normal,turbines_powers_false_disable,atol=0.1) # Confirm the same for run_no_wake - fi.run_no_wake() - turbines_powers_normal = fi.get_turbine_powers() - fi.set(disable_turbines=np.zeros((2, 3), dtype=bool)) - fi.run_no_wake() - turbines_powers_false_disable = fi.get_turbine_powers() + fmodel.run_no_wake() + turbines_powers_normal = fmodel.get_turbine_powers() + fmodel.set(disable_turbines=np.zeros((2, 3), dtype=bool)) + fmodel.run_no_wake() + turbines_powers_false_disable = fmodel.get_turbine_powers() np.testing.assert_allclose(turbines_powers_normal,turbines_powers_false_disable,atol=0.1) # Confirm the shutting off the middle turbine is like removing from the layout # In terms of impact on third turbine disable_turbines = np.zeros((2, 3), dtype=bool) disable_turbines[:,1] = [True, True] - fi.set(disable_turbines=disable_turbines) - fi.run() - power_with_middle_disabled = fi.get_turbine_powers() + fmodel.set(disable_turbines=disable_turbines) + fmodel.run() + power_with_middle_disabled = fmodel.get_turbine_powers() # Two turbine case to compare against above - fi_remove_middle = fi.copy() - fi_remove_middle.set(layout_x=[0,2000], layout_y=[0, 0]) - fi_remove_middle.run() - power_with_middle_removed = fi_remove_middle.get_turbine_powers() + fmodel_remove_middle = fmodel.copy() + fmodel_remove_middle.set(layout_x=[0,2000], layout_y=[0, 0]) + fmodel_remove_middle.run() + power_with_middle_removed = fmodel_remove_middle.get_turbine_powers() np.testing.assert_almost_equal(power_with_middle_disabled[0,2], power_with_middle_removed[0,1]) np.testing.assert_almost_equal(power_with_middle_disabled[1,2], power_with_middle_removed[1,1]) # Check that yaw angles are correctly set when turbines are disabled - fi.set( + fmodel.set( layout_x=[0, 1000, 2000], layout_y=[0, 0, 0], disable_turbines=disable_turbines, yaw_angles=np.ones((2, 3)) ) - fi.run() - assert (fi.floris.farm.yaw_angles == np.array([[1.0, 0.0, 1.0], [1.0, 0.0, 1.0]])).all() + fmodel.run() + assert (fmodel.core.farm.yaw_angles == np.array([[1.0, 0.0, 1.0], [1.0, 0.0, 1.0]])).all() def test_get_farm_aep(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) wind_speeds = np.array([8.0, 8.0, 8.0]) wind_directions = np.array([270.0, 270.0, 270.0]) @@ -351,7 +353,7 @@ def test_get_farm_aep(): layout_y = np.array([0, 1000]) # n_turbines = len(layout_x) - fi.set( + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, turbulence_intensities=turbulence_intensities, @@ -359,15 +361,15 @@ def test_get_farm_aep(): layout_y=layout_y, ) - fi.run() + fmodel.run() - farm_powers = fi.get_farm_power() + farm_powers = fmodel.get_farm_power() # Start with uniform frequency freq = np.ones(n_findex) freq = freq / np.sum(freq) - farm_aep = fi.get_farm_AEP(freq=freq) + farm_aep = fmodel.get_farm_AEP(freq=freq) aep = np.sum(np.multiply(freq, farm_powers) * 365 * 24) @@ -375,7 +377,7 @@ def test_get_farm_aep(): np.testing.assert_allclose(farm_aep, aep) def test_get_farm_aep_with_conditions(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) wind_speeds = np.array([5.0, 8.0, 8.0, 8.0, 20.0]) wind_directions = np.array([270.0, 270.0, 270.0, 270.0, 270.0]) @@ -386,7 +388,7 @@ def test_get_farm_aep_with_conditions(): layout_y = np.array([0, 1000]) # n_turbines = len(layout_x) - fi.set( + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, turbulence_intensities=turbulence_intensities, @@ -394,9 +396,9 @@ def test_get_farm_aep_with_conditions(): layout_y=layout_y, ) - fi.run() + fmodel.run() - farm_powers = fi.get_farm_power() + farm_powers = fmodel.get_farm_power() # Start with uniform frequency freq = np.ones(n_findex) @@ -404,7 +406,7 @@ def test_get_farm_aep_with_conditions(): # Get farm AEP with conditions on minimun and max wind speed # which exclude the first and last findex - farm_aep = fi.get_farm_AEP(freq=freq, cut_in_wind_speed=6.0, cut_out_wind_speed=15.0) + farm_aep = fmodel.get_farm_AEP(freq=freq, cut_in_wind_speed=6.0, cut_out_wind_speed=15.0) # In this case the aep should be computed assuming 0 power # for the 0th and last findex @@ -416,34 +418,33 @@ def test_get_farm_aep_with_conditions(): np.testing.assert_allclose(farm_aep, aep) #Confirm n_findex reset after the operation - assert n_findex == fi.floris.flow_field.n_findex + assert n_findex == fmodel.core.flow_field.n_findex def test_set_ti(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) # Set wind directions, wind speeds and turbulence intensities with n_findex = 3 - fi.set( + fmodel.set( wind_speeds=[8.0, 8.0, 8.0], wind_directions=[240.0, 250.0, 260.0], turbulence_intensities=[0.1, 0.1, 0.1], ) # Confirm can change turbulence intensities if not changing the length of the array - fi.set(turbulence_intensities=[0.12, 0.12, 0.12]) + fmodel.set(turbulence_intensities=[0.12, 0.12, 0.12]) # Confirm that changes to wind speeds and directions without changing turbulence intensities # raises an error with pytest.raises(ValueError): - fi.set( + fmodel.set( wind_speeds=[8.0, 8.0, 8.0, 8.0], wind_directions=[240.0, 250.0, 260.0, 270.0], ) - # Changing the length of TI alone is not allowed with pytest.raises(ValueError): - fi.set(turbulence_intensities=[0.12]) + fmodel.set(turbulence_intensities=[0.12]) # Test that applying a float however raises an error with pytest.raises(TypeError): - fi.set(turbulence_intensities=0.12) + fmodel.set(turbulence_intensities=0.12) diff --git a/tests/flow_field_unit_test.py b/tests/flow_field_unit_test.py index 3c5001506..260c1f8df 100644 --- a/tests/flow_field_unit_test.py +++ b/tests/flow_field_unit_test.py @@ -2,7 +2,7 @@ import numpy as np import pytest -from floris.simulation import FlowField, TurbineGrid +from floris.core import FlowField, TurbineGrid from tests.conftest import N_FINDEX, N_TURBINES diff --git a/tests/layout_optimization_integration_test.py b/tests/layout_optimization_integration_test.py index 7e61311a4..dafd5e0d6 100644 --- a/tests/layout_optimization_integration_test.py +++ b/tests/layout_optimization_integration_test.py @@ -3,18 +3,18 @@ import numpy as np import pytest -from floris.tools import ( +from floris import ( + FlorisModel, TimeSeries, WindRose, ) -from floris.tools.floris_interface import FlorisInterface -from floris.tools.optimization.layout_optimization.layout_optimization_base import ( +from floris.optimization.layout_optimization.layout_optimization_base import ( LayoutOptimization, ) -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( +from floris.optimization.layout_optimization.layout_optimization_scipy import ( LayoutOptimizationScipy, ) -from floris.tools.wind_data import WindDataBase +from floris.wind_data import WindDataBase TEST_DATA = Path(__file__).resolve().parent / "data" @@ -23,7 +23,7 @@ def test_base_class(): # Get a test fi - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) # Set up a sample boundary boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] @@ -33,23 +33,23 @@ def test_base_class(): freq = np.ones((5, 5)) freq = freq / freq.sum() with pytest.raises(ValueError): - LayoutOptimization(fi, boundaries, freq, 5) + LayoutOptimization(fmodel, boundaries, freq, 5) # Passing as a keyword freq to wind_data should also fail with pytest.raises(ValueError): - LayoutOptimization(fi=fi, boundaries=boundaries, wind_data=freq, min_dist=5,) + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, wind_data=freq, min_dist=5,) time_series = TimeSeries( - wind_directions=fi.floris.flow_field.wind_directions, - wind_speeds=fi.floris.flow_field.wind_speeds, - turbulence_intensities=fi.floris.flow_field.turbulence_intensities, + wind_directions=fmodel.core.flow_field.wind_directions, + wind_speeds=fmodel.core.flow_field.wind_speeds, + turbulence_intensities=fmodel.core.flow_field.turbulence_intensities, ) wind_rose = time_series.to_wind_rose() # Passing wind_data objects in the 3rd position should not fail - LayoutOptimization(fi, boundaries, time_series, 5) - LayoutOptimization(fi, boundaries, wind_rose, 5) + LayoutOptimization(fmodel, boundaries, time_series, 5) + LayoutOptimization(fmodel, boundaries, wind_rose, 5) # Passing wind_data objects by keyword should not fail - LayoutOptimization(fi=fi, boundaries=boundaries, wind_data=time_series, min_dist=5) - LayoutOptimization(fi=fi, boundaries=boundaries, wind_data=wind_rose, min_dist=5) + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, wind_data=time_series, min_dist=5) + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, wind_data=wind_rose, min_dist=5) diff --git a/tests/layout_visualization_test.py b/tests/layout_visualization_test.py index f23340c56..055b15b1b 100644 --- a/tests/layout_visualization_test.py +++ b/tests/layout_visualization_test.py @@ -4,8 +4,8 @@ import matplotlib.pyplot as plt import numpy as np -import floris.tools.layout_visualization as layoutviz -from floris.tools.floris_interface import FlorisInterface +import floris.layout_visualization as layoutviz +from floris import FlorisModel TEST_DATA = Path(__file__).resolve().parent / "data" @@ -24,24 +24,24 @@ def test_get_wake_direction(): def test_plotting_functions(): - fi = FlorisInterface(configuration=YAML_INPUT) + fmodel = FlorisModel(configuration=YAML_INPUT) - ax = layoutviz.plot_turbine_points(fi=fi) + ax = layoutviz.plot_turbine_points(fmodel=fmodel) assert isinstance(ax, plt.Axes) - ax = layoutviz.plot_turbine_labels(fi=fi) + ax = layoutviz.plot_turbine_labels(fmodel=fmodel) assert isinstance(ax, plt.Axes) - ax = layoutviz.plot_turbine_rotors(fi=fi) + ax = layoutviz.plot_turbine_rotors(fmodel=fmodel) assert isinstance(ax, plt.Axes) - ax = layoutviz.plot_waking_directions(fi=fi) + ax = layoutviz.plot_waking_directions(fmodel=fmodel) assert isinstance(ax, plt.Axes) # Add additional turbines to test plot farm terrain - fi.set( + fmodel.set( layout_x=[0, 1000, 0, 1000, 3000], layout_y=[0, 0, 2000, 2000, 3000], ) - ax = layoutviz.plot_farm_terrain(fi=fi) + ax = layoutviz.plot_farm_terrain(fmodel=fmodel) assert isinstance(ax, plt.Axes) diff --git a/tests/parallel_computing_interface_integration_test.py b/tests/parallel_computing_interface_integration_test.py index 6b31297d5..099f65583 100644 --- a/tests/parallel_computing_interface_integration_test.py +++ b/tests/parallel_computing_interface_integration_test.py @@ -3,7 +3,7 @@ import numpy as np -from floris.tools import FlorisInterface, ParallelComputingInterface +from floris import FlorisModel, ParallelComputingInterface from tests.conftest import ( assert_results_arrays, ) @@ -22,24 +22,24 @@ def test_parallel_turbine_powers(sample_inputs_fixture): the serial floris interface. The expected result is that the turbine powers should be exactly the same. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - fi_serial = FlorisInterface(sample_inputs_fixture.floris) - fi_parallel_input = copy.deepcopy(fi_serial) - fi_serial.run() + fmodel_serial = FlorisModel(sample_inputs_fixture.core) + fmodel_parallel_input = copy.deepcopy(fmodel_serial) + fmodel_serial.run() - serial_turbine_powers = fi_serial.get_turbine_powers() + serial_turbine_powers = fmodel_serial.get_turbine_powers() - fi_parallel = ParallelComputingInterface( - fi=fi_parallel_input, + fmodel_parallel = ParallelComputingInterface( + fmodel=fmodel_parallel_input, max_workers=2, n_wind_condition_splits=2, interface="concurrent", print_timings=False, ) - parallel_turbine_powers = fi_parallel.get_turbine_powers() + parallel_turbine_powers = fmodel_parallel.get_turbine_powers() if DEBUG: print(serial_turbine_powers) diff --git a/tests/reg_tests/cumulative_curl_regression_test.py b/tests/reg_tests/cumulative_curl_regression_test.py index 8eba6eac7..8d47d0ebd 100644 --- a/tests/reg_tests/cumulative_curl_regression_test.py +++ b/tests/reg_tests/cumulative_curl_regression_test.py @@ -1,10 +1,10 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -189,10 +189,10 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -302,25 +302,25 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -346,10 +346,10 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -431,14 +431,14 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): correction enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = False - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = False + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -519,14 +519,14 @@ def test_regression_secondary_steering(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = False + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = False - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -623,8 +623,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -632,10 +632,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -678,20 +678,20 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/empirical_gauss_regression_test.py b/tests/reg_tests/empirical_gauss_regression_test.py index fce5e96be..224eb66de 100644 --- a/tests/reg_tests/empirical_gauss_regression_test.py +++ b/tests/reg_tests/empirical_gauss_regression_test.py @@ -1,10 +1,10 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -162,11 +162,11 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -276,26 +276,26 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -321,11 +321,11 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -406,15 +406,15 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): correction enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL # Turn on yaw added recovery - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True # First pass, leave at default value of 0; should then do nothing - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -483,10 +483,10 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): assert_results_arrays(test_results[0:4], yawed_baseline) # Second pass, use nonzero gain - sample_inputs_fixture.floris["wake"]["wake_deflection_parameters"]\ + sample_inputs_fixture.core["wake"]["wake_deflection_parameters"]\ ["empirical_gauss"]["yaw_added_mixing_gain"] = 0.1 - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -583,9 +583,9 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -593,10 +593,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -647,21 +647,21 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/gauss_regression_test.py b/tests/reg_tests/gauss_regression_test.py index 561323f72..bc876006b 100644 --- a/tests/reg_tests/gauss_regression_test.py +++ b/tests/reg_tests/gauss_regression_test.py @@ -1,10 +1,10 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -281,10 +281,10 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -394,26 +394,26 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -439,10 +439,10 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -523,12 +523,12 @@ def test_regression_gch(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed, yaw added recovery correction enabled, and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL ### With GCH off (via conftest), GCH should be same as Gauss - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -605,11 +605,11 @@ def test_regression_gch(sample_inputs_fixture): ### With GCH on, the results should change - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -691,14 +691,14 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): correction enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = False - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = False + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -779,14 +779,14 @@ def test_regression_secondary_steering(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = False + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = False - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -883,8 +883,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -892,10 +892,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -937,20 +937,20 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/jensen_jimenez_regression_test.py b/tests/reg_tests/jensen_jimenez_regression_test.py index ecb915fbc..775687077 100644 --- a/tests/reg_tests/jensen_jimenez_regression_test.py +++ b/tests/reg_tests/jensen_jimenez_regression_test.py @@ -1,10 +1,10 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -131,10 +131,10 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -244,25 +244,25 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -288,10 +288,10 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -388,8 +388,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -397,10 +397,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -454,20 +454,20 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/none_regression_test.py b/tests/reg_tests/none_regression_test.py index 5b98fa1a4..aff811938 100644 --- a/tests/reg_tests/none_regression_test.py +++ b/tests/reg_tests/none_regression_test.py @@ -2,10 +2,10 @@ import numpy as np import pytest -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -132,10 +132,10 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -245,25 +245,25 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -289,10 +289,10 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -324,8 +324,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -333,10 +333,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -379,20 +379,20 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/scipy_layout_opt_regression.py b/tests/reg_tests/scipy_layout_opt_regression.py index 570cb964c..049b1b841 100644 --- a/tests/reg_tests/scipy_layout_opt_regression.py +++ b/tests/reg_tests/scipy_layout_opt_regression.py @@ -2,8 +2,8 @@ import numpy as np import pandas as pd -from floris.tools import FlorisInterface -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( +from floris import FlorisModel +from floris.optimization.layout_optimization.layout_optimization_scipy import ( LayoutOptimizationScipy, ) from tests.conftest import ( @@ -29,8 +29,8 @@ def test_scipy_layout_opt(sample_inputs_fixture): compares the optimization results from the SciPy layout optimizaiton for a simple farm with a simple wind rose to stored baseline results. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL opt_options = { "maxiter": 5, @@ -42,18 +42,18 @@ def test_scipy_layout_opt(sample_inputs_fixture): boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] - fi = FlorisInterface(sample_inputs_fixture.floris) + fmodel = FlorisModel(sample_inputs_fixture.core) wd_array = np.arange(0, 360.0, 5.0) ws_array = 8.0 * np.ones_like(wd_array) D = 126.0 # Rotor diameter for the NREL 5 MW - fi.reinitialize( + fmodel.reinitialize( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, wind_speeds=ws_array, ) - layout_opt = LayoutOptimizationScipy(fi, boundaries, optOptions=opt_options) + layout_opt = LayoutOptimizationScipy(fmodel, boundaries, optOptions=opt_options) sol = layout_opt.optimize() locations_opt = np.array([sol[0], sol[1]]) diff --git a/tests/reg_tests/turbopark_regression_test.py b/tests/reg_tests/turbopark_regression_test.py index 16be779e4..d4ee6febe 100644 --- a/tests/reg_tests/turbopark_regression_test.py +++ b/tests/reg_tests/turbopark_regression_test.py @@ -1,10 +1,10 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Floris, + Core, power, rotor_effective_velocity, thrust_coefficient, @@ -90,11 +90,11 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -204,26 +204,26 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0, 8.0] - sample_inputs_fixture.floris["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -249,10 +249,10 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) yaw_angles[:,0] = 5.0 @@ -343,9 +343,9 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -353,10 +353,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -399,19 +399,19 @@ def test_full_flow_solver(sample_inputs_fixture): (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["solver"] = { + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { "type": "flow_field_planar_grid", "normal_vector": "z", - "planar_coordinate": sample_inputs_fixture.floris["farm"]["turbine_type"][0]["hub_height"], + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], "flow_field_grid_points": [5, 5], "flow_field_bounds": [None, None], } - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.solve_for_viz() velocities = floris.flow_field.u_sorted diff --git a/tests/reg_tests/yaw_optimization_regression_test.py b/tests/reg_tests/yaw_optimization_regression_test.py index ea353eadc..203856646 100644 --- a/tests/reg_tests/yaw_optimization_regression_test.py +++ b/tests/reg_tests/yaw_optimization_regression_test.py @@ -2,12 +2,12 @@ import numpy as np import pandas as pd -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric import ( +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( YawOptimizationGeometric, ) -from floris.tools.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR DEBUG = False @@ -77,16 +77,16 @@ def test_serial_refine(sample_inputs_fixture): optimization scheme. This test compares the optimization results from the SR method for a simple farm with a simple wind rose to stored baseline results. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - fi = FlorisInterface(sample_inputs_fixture.floris) + fmodel = FlorisModel(sample_inputs_fixture.core) wd_array = np.arange(0.0, 360.0, 90.0) ws_array = 8.0 * np.ones_like(wd_array) ti_array = 0.1 * np.ones_like(wd_array) D = 126.0 # Rotor diameter for the NREL 5 MW - fi.set( + fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, @@ -94,7 +94,7 @@ def test_serial_refine(sample_inputs_fixture): turbulence_intensities=ti_array, ) - yaw_opt = YawOptimizationSR(fi) + yaw_opt = YawOptimizationSR(fmodel) df_opt = yaw_opt.optimize() if DEBUG: @@ -110,31 +110,31 @@ def test_geometric_yaw(sample_inputs_fixture): optimal yaw relationships. This test compares the optimization results from the Geometric Yaw optimization for a simple farm with a simple wind rose to stored baseline results. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - fi = FlorisInterface(sample_inputs_fixture.floris) + fmodel = FlorisModel(sample_inputs_fixture.core) wd_array = np.arange(0.0, 360.0, 90.0) ws_array = 8.0 * np.ones_like(wd_array) ti_array = 0.1 * np.ones_like(wd_array) D = 126.0 # Rotor diameter for the NREL 5 MW - fi.set( + fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array, ) - fi.run() - baseline_farm_power = fi.get_farm_power().squeeze() + fmodel.run() + baseline_farm_power = fmodel.get_farm_power().squeeze() - yaw_opt = YawOptimizationGeometric(fi) + yaw_opt = YawOptimizationGeometric(fmodel) df_opt = yaw_opt.optimize() yaw_angles_opt_geo = np.vstack(yaw_opt.yaw_angles_opt) - fi.set(yaw_angles=yaw_angles_opt_geo) - fi.run() - geo_farm_power = fi.get_farm_power().squeeze() + fmodel.set(yaw_angles=yaw_angles_opt_geo) + fmodel.run() + geo_farm_power = fmodel.get_farm_power().squeeze() df_opt['farm_power_baseline'] = baseline_farm_power df_opt['farm_power_opt'] = geo_farm_power @@ -152,8 +152,8 @@ def test_scipy_yaw_opt(sample_inputs_fixture): compares the optimization results from the SciPy yaw optimization for a simple farm with a simple wind rose to stored baseline results. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL opt_options = { "maxiter": 5, @@ -163,12 +163,12 @@ def test_scipy_yaw_opt(sample_inputs_fixture): "eps": 0.5, } - fi = FlorisInterface(sample_inputs_fixture.floris) + fmodel = FlorisModel(sample_inputs_fixture.core) wd_array = np.arange(0.0, 360.0, 90.0) ws_array = 8.0 * np.ones_like(wd_array) ti_array = 0.1 * np.ones_like(wd_array) D = 126.0 # Rotor diameter for the NREL 5 MW - fi.set( + fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], wind_directions=wd_array, @@ -176,7 +176,7 @@ def test_scipy_yaw_opt(sample_inputs_fixture): turbulence_intensities=ti_array, ) - yaw_opt = YawOptimizationScipy(fi, opt_options=opt_options) + yaw_opt = YawOptimizationScipy(fmodel, opt_options=opt_options) df_opt = yaw_opt.optimize() if DEBUG: diff --git a/tests/rotor_velocity_unit_test.py b/tests/rotor_velocity_unit_test.py index 30b19f346..468b7a887 100644 --- a/tests/rotor_velocity_unit_test.py +++ b/tests/rotor_velocity_unit_test.py @@ -1,7 +1,7 @@ import numpy as np -from floris.simulation import Turbine -from floris.simulation.rotor_velocity import ( +from floris.core import Turbine +from floris.core.rotor_velocity import ( average_velocity, compute_tilt_angles_for_floating_turbines, compute_tilt_angles_for_floating_turbines_map, diff --git a/tests/turbine_grid_unit_test.py b/tests/turbine_grid_unit_test.py index c65a90a29..3d9b01961 100644 --- a/tests/turbine_grid_unit_test.py +++ b/tests/turbine_grid_unit_test.py @@ -1,7 +1,7 @@ import numpy as np -from floris.simulation import TurbineGrid +from floris.core import TurbineGrid from tests.conftest import ( N_FINDEX, N_TURBINES, diff --git a/tests/turbine_multi_dim_unit_test.py b/tests/turbine_multi_dim_unit_test.py index 39f1b1f1a..55b582e41 100644 --- a/tests/turbine_multi_dim_unit_test.py +++ b/tests/turbine_multi_dim_unit_test.py @@ -5,11 +5,11 @@ import pandas as pd import pytest -from floris.simulation import ( +from floris.core import ( Turbine, ) -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT -from floris.simulation.turbine.turbine import ( +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.core.turbine.turbine import ( axial_induction, power, thrust_coefficient, diff --git a/tests/turbine_operation_models_integration_test.py b/tests/turbine_operation_models_integration_test.py index 446695855..4732bd555 100644 --- a/tests/turbine_operation_models_integration_test.py +++ b/tests/turbine_operation_models_integration_test.py @@ -1,7 +1,7 @@ import numpy as np import pytest -from floris.simulation.turbine.operation_models import ( +from floris.core.turbine.operation_models import ( CosineLossTurbine, MixedOperationTurbine, POWER_SETPOINT_DEFAULT, diff --git a/tests/turbine_unit_test.py b/tests/turbine_unit_test.py index e366aeb11..2ef7a7d97 100644 --- a/tests/turbine_unit_test.py +++ b/tests/turbine_unit_test.py @@ -7,14 +7,14 @@ import pytest import yaml -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, power, thrust_coefficient, Turbine, ) -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT from tests.conftest import SampleInputs, WIND_SPEEDS diff --git a/tests/uncertainty_interface_integration_test.py b/tests/uncertainty_interface_integration_test.py index 74bf956b0..8e0d4fd8f 100644 --- a/tests/uncertainty_interface_integration_test.py +++ b/tests/uncertainty_interface_integration_test.py @@ -4,9 +4,9 @@ import pytest import yaml -from floris.simulation.turbine.operation_models import POWER_SETPOINT_DEFAULT -from floris.tools.floris_interface import FlorisInterface -from floris.tools.uncertainty_interface import UncertaintyInterface +from floris import FlorisModel +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.uncertainty_interface import UncertaintyInterface TEST_DATA = Path(__file__).resolve().parent / "data" @@ -14,12 +14,12 @@ def test_read_yaml(): - fi = UncertaintyInterface(configuration=YAML_INPUT) - assert isinstance(fi, UncertaintyInterface) + umodel = UncertaintyInterface(configuration=YAML_INPUT) + assert isinstance(umodel, UncertaintyInterface) def test_rounded_inputs(): - fi = UncertaintyInterface(configuration=YAML_INPUT) + umodel = UncertaintyInterface(configuration=YAML_INPUT) # Using defaults # Example input array @@ -29,13 +29,13 @@ def test_rounded_inputs(): expected_output = np.array([[45.0, 8.0, 0.25, 91.0, 700.0], [60.0, 8.0, 0.3, 95.0, 800.0]]) # Call the function - rounded_inputs = fi._get_rounded_inputs(input_array) + rounded_inputs = umodel._get_rounded_inputs(input_array) np.testing.assert_almost_equal(rounded_inputs, expected_output) def test_expand_wind_directions(): - fi = UncertaintyInterface(configuration=YAML_INPUT) + umodel = UncertaintyInterface(configuration=YAML_INPUT) input_array = np.array( [[1, 20, 30], [40, 50, 60], [70, 80, 90], [100, 110, 120], [359, 140, 150]] @@ -44,16 +44,16 @@ def test_expand_wind_directions(): # Test even length with pytest.raises(ValueError): wd_sample_points = [-15, -10, -5, 5, 10, 15] # Even lenght - fi._expand_wind_directions(input_array, wd_sample_points) + umodel._expand_wind_directions(input_array, wd_sample_points) # Test middle element not 0 with pytest.raises(ValueError): wd_sample_points = [-15, -10, -5, 1, 5, 10, 15] # Odd length, not 0 at the middle - fi._expand_wind_directions(input_array, wd_sample_points) + umodel._expand_wind_directions(input_array, wd_sample_points) # Test correction operations wd_sample_points = [-15, -10, -5, 0, 5, 10, 15] # Odd length, 0 at the middle - output_array = fi._expand_wind_directions(input_array, wd_sample_points) + output_array = umodel._expand_wind_directions(input_array, wd_sample_points) # Check if output shape is correct assert output_array.shape[0] == 35 @@ -68,7 +68,7 @@ def test_expand_wind_directions(): def test_get_unique_inputs(): - fi = UncertaintyInterface(configuration=YAML_INPUT) + umodel = UncertaintyInterface(configuration=YAML_INPUT) input_array = np.array( [ @@ -82,7 +82,7 @@ def test_get_unique_inputs(): expected_unique_inputs = np.array([[0, 1], [0, 2], [1, 1]]) - unique_inputs, map_to_expanded_inputs = fi._get_unique_inputs(input_array) + unique_inputs, map_to_expanded_inputs = umodel._get_unique_inputs(input_array) # test expected result assert np.array_equal(unique_inputs, expected_unique_inputs) @@ -92,8 +92,8 @@ def test_get_unique_inputs(): def test_get_weights(): - fi = UncertaintyInterface(configuration=YAML_INPUT) - weights = fi._get_weights(3.0, [-6, -3, 0, 3, 6]) + umodel = UncertaintyInterface(configuration=YAML_INPUT) + weights = umodel._get_weights(3.0, [-6, -3, 0, 3, 6]) np.testing.assert_allclose( weights, np.array([0.05448868, 0.24420134, 0.40261995, 0.24420134, 0.05448868]) ) @@ -102,10 +102,10 @@ def test_get_weights(): def test_uncertainty_interface(): # Recompute uncertain result using certain result with 1 deg - fi_nom = FlorisInterface(configuration=YAML_INPUT) - fi_unc = UncertaintyInterface(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) + fmodel = FlorisModel(configuration=YAML_INPUT) + umodel = UncertaintyInterface(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) - fi_nom.set( + fmodel.set( layout_x=[0, 300], layout_y=[0, 0], wind_speeds=[8.0, 8.0, 8.0], @@ -113,7 +113,7 @@ def test_uncertainty_interface(): turbulence_intensities=[0.06, 0.06, 0.06], ) - fi_unc.set( + umodel.set( layout_x=[0, 300], layout_y=[0, 0], wind_speeds=[8.0], @@ -121,22 +121,22 @@ def test_uncertainty_interface(): turbulence_intensities=[0.06], ) - fi_nom.run() - fi_unc.run() + fmodel.run() + umodel.run() - nom_powers = fi_nom.get_turbine_powers()[:, 1].flatten() - unc_powers = fi_unc.get_turbine_powers()[:, 1].flatten() + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() + unc_powers = umodel.get_turbine_powers()[:, 1].flatten() - weights = fi_unc.weights + weights = umodel.weights np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) def test_uncertainty_interface_setpoints(): - fi_nom = FlorisInterface(configuration=YAML_INPUT) - fi_unc = UncertaintyInterface(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) + fmodel = FlorisModel(configuration=YAML_INPUT) + umodel = UncertaintyInterface(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) - fi_nom.set( + fmodel.set( layout_x=[0, 300], layout_y=[0, 0], wind_speeds=[8.0, 8.0, 8.0], @@ -144,41 +144,41 @@ def test_uncertainty_interface_setpoints(): turbulence_intensities=[0.06, 0.06, 0.06], ) - fi_unc.set( + umodel.set( layout_x=[0, 300], layout_y=[0, 0], wind_speeds=[8.0], wind_directions=[270.0], turbulence_intensities=[0.06], ) - weights = fi_unc.weights + weights = umodel.weights # Check setpoints dimensions are respected and reset_operation works - # Note that fi_nom.set() does NOT raise ValueError---an AttributeError is raised only at - # fi_nom.run()---whereas fi_unc.set raises ValueError immediately. - # fi_nom.set(yaw_angles=np.array([[0.0, 0.0]])) + # Note that fmodel.set() does NOT raise ValueError---an AttributeError is raised only at + # fmodel.run()---whereas umodel.set raises ValueError immediately. + # fmodel.set(yaw_angles=np.array([[0.0, 0.0]])) # with pytest.raises(AttributeError): - # fi_nom.run() + # fmodel.run() # with pytest.raises(ValueError): - # fi_unc.set(yaw_angles=np.array([[0.0, 0.0]])) + # umodel.set(yaw_angles=np.array([[0.0, 0.0]])) - fi_nom.set(yaw_angles=np.array([[20.0, 0.0], [20.0, 0.0], [20.0, 0.0]])) - fi_nom.run() - nom_powers = fi_nom.get_turbine_powers()[:, 1].flatten() + fmodel.set(yaw_angles=np.array([[20.0, 0.0], [20.0, 0.0], [20.0, 0.0]])) + fmodel.run() + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() - fi_unc.set(yaw_angles=np.array([[20.0, 0.0]])) - fi_unc.run() - unc_powers = fi_unc.get_turbine_powers()[:, 1].flatten() + umodel.set(yaw_angles=np.array([[20.0, 0.0]])) + umodel.run() + unc_powers = umodel.get_turbine_powers()[:, 1].flatten() np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) # Drop yaw setpoints and rerun - fi_nom.reset_operation() - fi_nom.run() - nom_powers = fi_nom.get_turbine_powers()[:, 1].flatten() + fmodel.reset_operation() + fmodel.run() + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() - fi_unc.reset_operation() - fi_unc.run() - unc_powers = fi_unc.get_turbine_powers()[:, 1].flatten() + umodel.reset_operation() + umodel.run() + unc_powers = umodel.get_turbine_powers()[:, 1].flatten() np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) diff --git a/tests/wake_unit_tests.py b/tests/wake_unit_tests.py index 09e66787c..90f66057e 100644 --- a/tests/wake_unit_tests.py +++ b/tests/wake_unit_tests.py @@ -1,5 +1,5 @@ -from floris.simulation import WakeModelManager +from floris.core import WakeModelManager from tests.conftest import SampleInputs diff --git a/tests/wind_data_integration_test.py b/tests/wind_data_integration_test.py index 66782733a..ecc8281b3 100644 --- a/tests/wind_data_integration_test.py +++ b/tests/wind_data_integration_test.py @@ -1,12 +1,12 @@ import numpy as np import pytest -from floris.tools import ( +from floris import ( TimeSeries, WindRose, WindTIRose, ) -from floris.tools.wind_data import WindDataBase +from floris.wind_data import WindDataBase class ChildClassTest(WindDataBase):