diff --git a/CHANGELOG.md b/CHANGELOG.md index 8d263f22..7b709aab 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,5 @@ (changelog)= -# ORBIT Changelog +# Changelog ## Unreleased @@ -10,6 +10,9 @@ for direct saving without user modification. - Fixes a bug in `CustomArraySystemDesign.create_project_csv()` where the output file location does not adjust to the user's `folder` input. +- Adds a contributor's guide to clearly delineate how to install and use the various developer's + tools. +- Modernize and streamline the installation instructions. ## 1.2.6 diff --git a/README.md b/README.md new file mode 100644 index 00000000..66b83dde --- /dev/null +++ b/README.md @@ -0,0 +1,156 @@ +# ORBIT + +Offshore Renewables Balance of system and Installation Tool + +[![PyPI version](https://badge.fury.io/py/orbit-nrel.svg)](https://badge.fury.io/py/orbit-nrel) +[![PyPI downloads](https://img.shields.io/pypi/dm/orbit-nrel?link=https%3A%2F%2Fpypi.org%2Fproject%2Forbit-nrel%2F)](https://pypi.org/project/orbit-nrel/) +[![Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) +[![image](https://img.shields.io/pypi/pyversions/orbit-nrel.svg)](https://pypi.python.org/pypi/orbit-nrel) + +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/NLRWindSystems/ORBIT/dev?filepath=examples) +[![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit) +[![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) +[![isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/) +[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) + +## Authors + +- [Jake Nunemaker](https://www.linkedin.com/in/jake-nunemaker/) +- [Matt Shields](https://www.linkedin.com/in/matt-shields-834a6b66/) +- [Rob Hammond](https://www.linkedin.com/in/rob-hammond-33583756/) +- [Nick Riccobono](https://www.linkedin.com/in/nicholas-riccobono-674a3b43/) + +### Curent Maintainers + +- Rob Hammond + +## Documentation + +Please visit the documentation site at https://nlrwindsystems.github.io/ORBIT/ + +## Installation + +`pip install orbit-nrel` + +### Environment Setup + +It is highly recommended to use separate Python environments for all projects, as such we recommend +using Anaconda or Miniconda for a lightweight version of Anaconda. Please visit their +documentation for installation details. This guide will assume the use of Miniconda throughout. + +1. Download the latest version of [Miniconda](https://docs.conda.io/en/latest/miniconda.html). +2. Create a new environment. Below, we're using the name `orbit` for the environment, but + any name is allowed, just replace "orbit" with whichever name was used throughout the + installation instructions. Similarly, any compatible Python version is allowed even though we + specify 3.13 below. + + ```bash + conda create -n orbit python=3.13 + ``` + +3. Activate the environment. + + ```bash + conda activate orbit + ``` + + To deactivate an environment, simply use `conda deactivate`. + +4. Install ORBIT. See the pip installation directions above, or either of the source + or development sections below for further details. + +### Running Examples + +For users wishing to run the examples provided as Jupyter Notebooks, please either install +the Jupyter Lab (preferred) or Jupyter Notebook library. + +```bash +pip install jupyterlab +``` + +### Source Installation + +For users looking to modify ORBIT or build their own models to incorporte, installing +from the source code is required. + +1. Open a terminal/Anaconda Prompt session and navigate to your desired folder location + + ```bash + cd /path/to/desired/folder + ``` + +2. Clone the repository (or your fork). If cloning your own fork, replace "NLRWindSystems" + with your GitHub username. + + ```bash + git clone https://github.com/NLRWindSystems/ORBIT.git + ``` + +3. Enter the repository. + + ```bash + cd ORBIT + ``` + +4. Install ORBIT. + + ```bash + pip install . + ``` + + For an editable installation that updates the installed version of ORBIT with any local changes, + use the `-e` flag. + + ```bash + pip install -e . + ``` + +### Development Setup + +For more advanced users, such as those interested in building the documentation localling, running +tests, or even contributing code back to the library, please use the following instructions. + +1. Open a terminal/Anaconda Prompt session and navigate to your desired folder location + + ```bash + cd /path/to/desired/folder + ``` + +2. If you are going to contribute code back to the library, fork the repository as you will not + be able to push your code changes to the library otherwise. + +3. Clone the repository (or your fork). If cloning your own fork, replace "NLRWindSystems" + with your GitHub username. + + ```bash + git clone https://github.com/NLRWindSystems/ORBIT.git + ``` + +4. Enter the repository. + + ```bash + cd ORBIT + ``` + +5. Install an editable version of ORBIT. + + ```bash + pip install -3 . + ``` + + For developers install the developer dependences in addition: + + ```bash + pip install -e .[dev,docs] + ``` + + - `dev`: automated code linting and formatting tools, plus the testing suite. + - `docs`: documentation building tools + +6. If contributing code back to the library, install the pre-commit hook to enable automated + formatting and linting. If this step is skipped, your PR will fail in the CI pipeline, and code + will not be reviewed until at least this step passes. + + ```bash + pre-commit install + ``` diff --git a/README.rst b/README.rst deleted file mode 100644 index 58a12671..00000000 --- a/README.rst +++ /dev/null @@ -1,134 +0,0 @@ -ORBIT -===== - -Offshore Renewables Balance of system and Installation Tool - -|PyPI version| |PyPI downloads| |Apache 2.0| |image| - -|Binder| |Pre-commit| |Black| |isort| |Ruff| - -:Authors: `Jake Nunemaker `_, `Matt Shields `_, `Rob Hammond `_, `Nick Riccobono `_ -:Documentation: `ORBIT Docs `_ - -Installation ------------- - -As of version 0.5.2, ORBIT is now pip installable with ``pip install orbit-nrel``. - -Development Setup ------------------ - -The steps below are for more advanced users that would like to modify and -and contribute to ORBIT. - -Environment -~~~~~~~~~~~ - -A couple of notes before you get started: - - It is assumed that you will be using the terminal on MacOS/Linux or the - Anaconda Prompt on Windows. The instructions refer to both as the - "terminal", and unless otherwise noted the commands will be the same. - - To verify git is installed, run ``git --version`` in the terminal. If an error - occurs, install git using these `directions `_. - - The listed installation process is intended to be the easiest for any OS - to get started. An alternative setup that doesn't rely on Anaconda for - setting up an environment can be followed - `here `_. - -Instructions -~~~~~~~~~~~~ - -1. Download the latest version of `Miniconda `_ - for the appropriate OS. Follow the remaining `steps `_ - for the appropriate OS version. -2. From the terminal, install pip by running: ``conda install -c anaconda pip`` -3. Next, create a new environment for the project with the following. - - .. code-block:: console - - conda create -n python=3.10 --no-default-packages - - To activate/deactivate the environment, use the following commands. - - .. code-block:: console - - conda activate - conda deactivate - -4. Clone the repository: - ``git clone https://github.com/NLRWindSystems/ORBIT.git`` -5. Navigate to the top level of the repository - (``/ORBIT/``) and install ORBIT as an editable package - with following command. - - .. code-block:: console - - # Note the "." at the end - pip install -e . - - # OR if you are you going to be contributing to the code or building documentation - pip install -e '.[dev]' - - # OR if you wish to use native plotting tools - pip install -e '.[plot]' - -6. (Development only) Install the pre-commit hooks to autoformat and lint code. - - .. code-block:: console - - pre-commit install - -Dependencies -~~~~~~~~~~~~ - -- Python >=3.10, <=3.13 -- marmot-agents -- SimPy -- NumPy -- Pandas -- SciPy -- OpenMDAO (>=3.2) -- python-benedict -- statsmodels -- PyYAML - -Development Specific -~~~~~~~~~~~~~~~~~~~~ - -- pre-commit -- black -- isort -- ruff -- pytest -- pytest-cov -- sphinx -- sphinx-rtd-theme - -Optional Plotting -~~~~~~~~~~~~~~~~~ -- matplotlib - -Recommended packages for easy iteration and running of code: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -- jupyterlab - - -.. |PyPI version| image:: https://badge.fury.io/py/orbit-nrel.svg - :target: https://badge.fury.io/py/orbit-nrel -.. |PyPI downloads| image:: https://img.shields.io/pypi/dm/orbit-nrel?link=https%3A%2F%2Fpypi.org%2Fproject%2Forbit-nrel%2F - :target: https://pypi.org/project/orbit-nrel/ -.. |Apache 2.0| image:: https://img.shields.io/badge/License-Apache%202.0-blue.svg - :target: https://opensource.org/licenses/Apache-2.0 -.. |image| image:: https://img.shields.io/pypi/pyversions/orbit-nrel.svg - :target: https://pypi.python.org/pypi/orbit-nrel -.. |Binder| image:: https://mybinder.org/badge_logo.svg - :target: https://mybinder.org/v2/gh/NLRWindSystems/ORBIT/dev?filepath=examples -.. |Pre-commit| image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white - :target: https://github.com/pre-commit/pre-commit -.. |Black| image:: https://img.shields.io/badge/code%20style-black-000000.svg - :target: https://github.com/psf/black -.. |isort| image:: https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336 - :target: https://pycqa.github.io/isort/ -.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json - :target: https://github.com/astral-sh/ruff diff --git a/docs/CONTRIBUTING.md b/docs/CONTRIBUTING.md new file mode 100644 index 00000000..de4e2709 --- /dev/null +++ b/docs/CONTRIBUTING.md @@ -0,0 +1,208 @@ +# Contributor's Guide + +We welcome contributions in the form of bug reports, bug fixes, improvements to the documentation, +ideas for enhancements (or the enhancements themselves!). + +You can find a [list of current issues](https://github.com/NLRWindSystems/ORBIT/issues) in the +project's GitHub repo. Feel free to tackle any existing bugs or enhancement ideas by submitting a +[pull request](https://github.com/NLRWindSystems/ORBIT/pulls). + +## Installing ORBIT for Developers + +Please read the +[developer's setup section of the installation guide](./getting_started/install.md#development-setup) +on the previous page for setting up a developer environment with ORBIT's developer tools. + +## Bug Reports + +* Please include a short (but detailed) Python snippet or explanation for reproducing the problem. + Be sure to attach or include a link to any input files that will be needed to reproduce the error. +* Explain the behavior you expected, and how what you got differed. + +## Pull Requests + +* Changes should be pass the linting and autoformatting checks provided through `pre-commit`. + If they do not, the PR's CI pipeline will fail and will block the acceptance of your + contributions until they pass. If your commit fails, then check the `pre-commit` logs to see + if any fixes were automatically applied or if manual changes are required. Once the changes are + made, simply reattempt to add and commit your files. +* Keep style fixes to a separate commit to make your pull request more readable. +* Docstrings are required and should follow the + [NumPy style](https://www.sphinx-doc.org/en/master/usage/extensions/example_numpy.html). +* When you start working on a pull request, start by creating a new branch pointing at the latest + commit on [dev](https://github.com/NLRWindSystems/ORBIT/tree/dev) based on your own fork (i.e., + replace "NLRWindSystems" with your GitHub username). +* The ORBIT copyright policy is detailed in the [`LICENSE`](https://github.com/NLRWindSystems/ORBIT/blob/main/LICENSE). +* Build the docs locally, and check that the build status of all examples in the + [tutorials](#tutorials) and [topical guides](#topical-guides). If any build fails, + be sure to fix the newly broken functionality. See the [documentation section](#documentation) + for more details on building the documentation + +## Documentation + +When contributing new features or fixing existing capabilities, be sure to add and/or update the +docstrings as needed to ensure the documentation site stays up to date with the latest changes. +Please also update any relevant guides or examples in the documentation if functionality has +changed, or if there is new functionality that should be highlighted. + +### Minor Updates + +To build the documentation locally, the following command can be run in your terminal in the `docs/` +directory of the repository. In general, this command should be used when the documentation does +not need to be rebuilt from scratch. + +```bash +jupyter-book build . +``` + +### Prior to a Pull Request + +When overhauling any sections of the documentation, wanting a clean build, or prior to submitting +a pull request, the following command should be run in the terminal from within the `docs/` +directory. This command encapsulates the above, but it removes any previously built versions of +the documentation, and copies over the updated Jupyter Notebook examples. The rebuilt `.ipynb` +files will all need to be added and committed to ensure the examples stay up to date with the +documentation. + +```bash +sh build_book.sh +``` + +### Viewing the Locally Built Documentation + +In addition to building the documentation, be sure to check the results by opening the following +path in your browser: `file:////ORBIT/docs/_build/html/index.html`. + +```{note} +If the browser appears to be out of date from what you expected to be built, please try reloading +the page a few times. If that doesn't work, then: + +1. Close the documentation tab +2. Clear your browser's cache +3. Rebuild the docs using [prior to a PR section](#prior-to-a-pull-request) +4. Open the page again. +``` + +### Writing Executable Content + +All executable content, such as Jupyter notebooks, should be converted to the executable markdown +format used by Jupyter Book. For users that prefer to develop examples in Jupyter notebooks, then +Jupytext (separate installation required) can be used to convert their work using the following +command. For more details, please see their documentation: +https://jupytext.readthedocs.io/en/latest/using-cli.html. + +```bash +jupytext notebook.ipynb --to myst +``` + +Similarly, any documentation example that users wish to interact with can be converted to a notebook +using the following command. + +```bash +jupytext notebook.md --to .ipynb +``` + +## Tests + +The test suite can be run using `pytest tests/`. Individual test files can be run by specifying them: + +```bash +pytest tests/tes_library.py +``` + +and individual tests can be run within those files + +```bash +pytest tests/test_library.py -k test_initialize_library +``` + +When you push to your fork, or open a PR, your tests will be run against the +[Continuous Integration (CI)](https://github.com/NLRWindSystems/ORBIT/actions) suite. This will start a build +that runs all tests on your branch against multiple Python versions, and will also test +documentation builds. + +## Code Review Process + +All pull requests will be reviewed by at least one other person before being merged into the dev +or main branch. Here are some guidelines to help with the review process, both as the person +submitting the pull request, and as the reviewer. + +### Code or Documentation Contributor + +* Quality is a priority -- take the time to ensure your code is clear, well-documented, and tested. +* Keep pull requests small enough to be reviewed in under 30 minutes; this helps reviewers give + thorough feedback and makes the process more efficient. +* Value readability and understandability, but balance this with computational efficiency. Readable + code is preferred unless a more abstract or optimized approach is clearly necessary and + well-justified. +* Be open to discussion and feedback. If written communication becomes challenging, consider + scheduling a call to clarify intent and resolve misunderstandings. +* Express appreciation for feedback, even if it's critical -- good reviews take time and effort. +* NLR employees, when requesting a review, notify the reviewer directly (e.g., via email or Teams) + to ensure timely attention. +* Ask for a review, not just approval. The goal is to improve the codebase together and constructive + feedback is an integral part of that process. + +### Code Reviewer + +* Test the code locally when possible to verify changes. +* Aim to either accept the pull request or request specific changes, rather than leaving only comments. +* Provide feedback constructively -- focus on the code and its functionality, not the person who wrote it. +* If you leave several critical suggestions, include positive feedback on aspects you appreciate. +* Communicate promptly once the PR author has addressed your feedback; aim to complete reviews + within 2-3 days barring extenuating circumstances. +* Remember, communication is key -- maintain a collaborative and respectful tone throughout the process. + +```{note} +Code readability and understandability are highly valued, but not if there are noticeable tradeoffs +in efficiency. Strive for a balance between clear code and appropriate performance, i.e., avoid +overly clever one liners, but vectorize and flatten control flow where possible. +``` + +## Release Process + +### Standard + +Most contributions will be into the `dev` branch, and once the threshold for a release has been +met the following steps should be taken to create a new release + +1. On `dev`, bump the version appropriately, see the + [semantic versioning guidelines](https://semver.org/) for details. +2. Open a pull request from `dev` into `main`. +3. When all CI tests pass, and the PR has been approved, merge the PR into main. +4. Pull the latest changes from GitHub into the local copy of the main branch. +5. Tag the latest commit to match the version bump in step 1 (replace "v1.2.3" in all instances + below), and push it to the repository. + + ```bash + git tag -a v1.2.3 -m "v1.2.3 release" + git push --origin v1.2.3 + ``` + +6. Check that the + [Test PyPI GitHub Action](https://github.com/NLRWindSystems/ORBIT/actions/workflows/publish_to_test_pypi.yml) + has run successfully. + 1. If the action failed, identify and fix the issue, then + 2. delete the local and remote tag using the following (replace "v1.2.3" in all instances just like + in step 5): + + ```bash + git tag -d v1.2.3 + git push --delete origin v1.2.3 + ``` + + 3. Start back at step 1. +7. When the Test PyPI Action has successfully run, + [create a new release](https://github.com/NLRWindSystems/ORBIT/releases/new) using the tag created in + step 5. + +### Patches + +Any pull requests directly into the main branch that alter the H2Integrate model (excludes anything +in `docs/`, or outside of `ORBIT/` and `tests/`), should be sure to follow the instructions +below: + +1. All CI tests pass and the patch version has been bumped according to the + [semantic versioning guidelines](https://semver.org/). +2. Follow steps 4 through 7 above. +3. Merge the NLR main branch back into the develop branch and push the changes. diff --git a/docs/_config.yml b/docs/_config.yml index 8d1eaa79..72a493c5 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -12,12 +12,13 @@ exclude_patterns: [_build, Thumbs.db, .DS_Store, "**.ipynb_checkpoints"] execute: execute_notebooks: auto timeout: -1 - allow_errors: true + allow_errors: false exclude_patterns: - _build - Thumbs.db - DS_Store - "**.ipynb_checkpoints" + - "topical_guides/cost_curves.md" # Define the name of the latex output file for PDF builds latex: @@ -125,3 +126,4 @@ sphinx: napoleon_use_admonition_for_notes: true napoleon_use_rtype: false nb_merge_streams: true + nb_execution_raise_on_error: true diff --git a/docs/_toc.yml b/docs/_toc.yml index cee72272..eec00dd9 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -9,6 +9,7 @@ parts: - file: getting_started/overview - file: getting_started/bos - file: getting_started/install + - file: CONTRIBUTING - caption: User Guide chapters: - file: tutorials/index @@ -22,7 +23,7 @@ parts: - file: topical_guides/fixed_bottom_installations - file: topical_guides/supply_chains - file: topical_guides/custom_array - - file: topical_guides/hvdc_hvac_export + - file: topical_guides/export_cable_system - file: topical_guides/cable_installation - caption: API Reference chapters: @@ -83,6 +84,6 @@ parts: - file: methods/CommonCost - caption: About chapters: - - file: publications - - file: ../CHANGELOG - - file: team + - file: about/publications + - file: about/team + - file: about/changelog diff --git a/docs/about/changelog.md b/docs/about/changelog.md new file mode 100644 index 00000000..d56aab8c --- /dev/null +++ b/docs/about/changelog.md @@ -0,0 +1,3 @@ +```{include} ../../CHANGELOG.md +:lang: markdown +``` diff --git a/docs/publications.md b/docs/about/publications.md similarity index 100% rename from docs/publications.md rename to docs/about/publications.md diff --git a/docs/team.md b/docs/about/team.md similarity index 92% rename from docs/team.md rename to docs/about/team.md index 1d59c60e..2c446291 100644 --- a/docs/team.md +++ b/docs/about/team.md @@ -10,6 +10,6 @@ - Nick Riccobono (NLR) - Daniel Mulas Hernando (NLR) -## Maintainer +## Maintainers - Rob Hammond (NLR) diff --git a/docs/getting_started/install.md b/docs/getting_started/install.md index 39be97aa..649e5e68 100644 --- a/docs/getting_started/install.md +++ b/docs/getting_started/install.md @@ -1,65 +1,7 @@ (installation)= # Installing ORBIT -```console -pip install orbit-nrel +```{include} ../../README.md +:lang: markdown +:start-after: "## Installation" ``` - -## Development Setup - -The steps below are for more advanced users that would like to modify and -and contribute to ORBIT. - -A couple of notes before you get started: - -- It is assumed that you will be using the terminal on MacOS/Linux or the - Anaconda Prompt on Windows. The instructions refer to both as the - "terminal", and unless otherwise noted the commands will be the same. -- To verify git is installed, run `git --version` in the terminal. If an error - occurs, install git using these [directions](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git). - -### Instructions - -1. Download the latest version of [Miniconda](https://docs.conda.io/en/latest/miniconda.html) - for the appropriate OS. Follow the remaining [steps](https://conda.io/projects/conda/en/latest/user-guide/install/index.html#regular-installation) - for the appropriate OS version. - -2. From the terminal, install pip by running: `conda install -c anaconda pip` - -3. Next, create a new environment for the project with the following. Change "orbit" to whatever - name you would like to give your environment, and "3.13" to whichever compatible version of - Python you prefer. - - ```console - conda create -n orbit python=3.13 -y - ``` - - To activate/deactivate the environment, use the following commands. - - ```console - conda activate orbit - conda deactivate orbit - ``` - -4. Clone the repository: - - ```bash - git clone https://github.com/NLRWindSystems/ORBIT.git - ``` - -5. Navigate to the top level of the repository (`/ORBIT/`) and install ORBIT as an - editable package with following command. - - ```console - # Note the "." at the end - pip install -e . - - # OR if you are you going to be contributing to the code or building documentation - pip install -e '.[dev]' - ``` - -6. (Development only) Install the pre-commit hooks to autoformat and lint code. - - ```console - pre-commit install - ``` diff --git a/docs/methods/CommonCost.md b/docs/methods/CommonCost.md index 28c6b730..ba19f30f 100644 --- a/docs/methods/CommonCost.md +++ b/docs/methods/CommonCost.md @@ -5,7 +5,7 @@ Establishing cost values for each installation process, component design, and pr parameter is essential to ORBIT's ability to calculate CapEx. Common costs and cost rates were specified as default values in each module and thus spread out across multiple files. Further, as modules were added or updated over time, these common costs were either updated -or were simply left as an older value. As of v1.2 (see {doc}`../../CHANGELOG`), all the common costs in the design modules +or were simply left as an older value. As of v1.2 (see the [changelog](#changelog)), all the common costs in the design modules were centralized under `common_cost.yaml`. That way, users can access a single file and update any number of costs they wish to change. @@ -37,7 +37,8 @@ in each vessel file in the `library/vessels` folder; and project costs are store /path/to/orbit/ORBIT/manager.py ``` -Questions regarding the methodology or organization of the common costs? Reach out to the {doc}`../team` +Questions regarding the methodology or organization of the common costs? Reach out to one of the +[current maintainers](#team) :::{note} This page is under construction and may receive an example in future releases. diff --git a/docs/topical_guides/cost_curves.md b/docs/topical_guides/cost_curves.md new file mode 100644 index 00000000..230bce02 --- /dev/null +++ b/docs/topical_guides/cost_curves.md @@ -0,0 +1,1022 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.19.1 +kernelspec: + display_name: bos + language: python + name: python3 +--- + +# Cost Curve Creator + +This notebook enables fitting curves to ORBIT models to create a cost function that can be +embedded in NRWAL. +A variety of curve and surface fitting options are available, and new ones can be added easily. +There are also tools for visualizing the ORBIT data and fitted curves. + +## Dependencies + +- ORBIT +- ipympl enables interactive matplotlib elements in jupyter notebooks via the `%matplotlib widget` magic command below + +## Instructions + +Follow the steps below to configure and run the notebook. + +1. Create a basic ORBIT configuration file including at least the following sections: +- site +- turbine +- plant + +2. Configure the notebook by setting the following variables in the "Configuration" section: +- `BASE_CONFIG`: the ORBIT config file at a given path +- `DEPTHS`: a list of water depths to use for cost curves +- `MEAN_WIND_SPEED`: a list of mean wind speed to use for cost curves +- Add any additional global parameter ranges + +3. Run the notebook to establish a first-pass fit for the ORBIT data. This will also plot the ORBIT +data and curves. + +4. Refine the curve fits by swapping the curve-fit function from the options available in +the "Curve Fit Library" section + +## Practical Guidance + +This notebook specifically models spatially varying costs typically related to water depth +but in some cases other variables are considered. The same methods could be used to model +the cost relationship for other variables. The general workflow is to first create a parameterized +ORBIT model and obtain the cost as a function of the variables of interest. +Then, fit a curve or surface to the data by starting with the linear options. +Plot the data and curve fits to evaluate whether the linear forms are sufficient. +If not, move to the quadratic or higher order curve fits. + +A class `CostFunction` is provided to simplify running the ORBIT parameterization, fit the +curves to the data, and visualize the results. An example is given below to instantiate the +class: +```python +cost_function = CostFunction( + config={"design_phases": ["MonopileDesign"]}, + parameters={ + "site.depth": DEPTHS, + "site.mean_windspeed": MEAN_WIND_SPEED, + }, + results={ + "monopile_unit_cost": lambda run: run.design_results["monopile"]["unit_cost"], + } +) +``` + +The config parameter is a dictionary containing additional configuration parameters to add to +the basic ORBIT configuration provided through the input file created in Step 1 in the instructions. +Any parameters given in the `CostFunction` config will be added to the base configuration or +overwritten if they already exist. The parameters dictionary contains the variables to be varied +in the cost function via `ORBIT.ParametricManager`, and the results dictionary sets the results +variables from ORBIT. Each of these dictionaries are passed directly to the +`ORBIT.ParametricManager` class. + +The fitted curves are saved on the `CostFunction` object and multiple types can exist at the +same time. Two versions of one type cannot be saved at the same time. To create a curve fit, +call one of the curve fit methods on the `CostFunction` instance. Then, an attribute is saved +on the instance with the curve fit type. + +Considerations: +- The `CostFunction` class supports parameterizations of at-most 2 variables. +- One instance of the `CostFunction` class can be used to fit multiple curves for a single + cost model. +- A new `CostFunction` instance should be created for each cost model. + +### Plotting API for 2D vs 3D plots +The `CostFunction` class handles 2D and 3D data seamlessly by using the x and z parameters for 2D +and adding y for 3D. The appropriate matplotlib API is used depending if the data is 2D or 3D. +From the calling script, be sure to configure the Axes that is given to `CostFunction.plot` with +the correct settings for 3D as listed in the table below. + +| Matplotlib setting | 2D | 3D | +|---------------------|----|----| +| Independent axis labels | `ax.set_xlabel()` | `ax.set_xlabel()`, `ax.set_zlabel()` | +| Dependent axis label | `ax.set_ylabel()` | `ax.set_zlabel()` | + +### Template workflow + +The following code block provides a template for creating a cost function for a model with +two independent parameters. + +```python + +# Create the CostFunction object with the ORBIT configuration for the parameterization +cost_function = CostFunction( + config={ + "design_phases": ["Design"], + }, + parameters={ + "site.depth": DEPTHS, + "site.mean_windspeed": MEAN_WIND_SPEED, + }, + results={ + "system_cost": lambda run: run.design_results["system"]["system_cost"], + } +) + +# Run ORBIT via ORBIT.ParametricManager +cost_function.run() + +# Fit two curves (surfaces since there are two independent parameters) to the data. +# After running the following two commands, the CostFunction object will have two related +# attributes that store the curve fits. +cost_function.fit_curve("linear_2d") +cost_function.fit_curve("quadratic_2d") + +# Plot the data and curves +fig = plt.figure() +ax = fig.add_subplot(1, 1, 1) +ax.set_title("Depth vs mean wind speed") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Mean wind speed (m/s)") +ax.set_zlabel("Cost ($)") +cost_function.plot(ax, plot_data=True) +cost_function.plot(ax, plot_curves=["linear_1d", "quadratic_1d"]) # These curves must have been generated first +# alternatively, the two lines above could be combined into a single line: +# cost_function.plot(ax, plot_data=True, plot_curves=["linear_1d", "quadratic_1d"]) + +# Export the curve function to a NRWAL-compatible file +cost_function.export("design.yaml", "design_system") +``` + +### Adding a new curve type + +There are a number of curve fit options in the `CostFunction` class, and more can be added by +creating a new method and connecting it in some key places in the class. +First, create a new method on the `CostFunction` class that follows the naming convention of +`{curve_type}_{dimension}` where `curve_type` is the name of the type of function like +"exponential" or "linear" and `dimension` is the number of independent variables the curve. +The function should return the fitted curve evaluated at the data points given to fit the curve. +A generic function signature is given below: +```python +class CostFunction: + + def curvetype_dimension(self): + + # Such as: + def linear_1d(self): +``` + +To fit a curve to the data for one independent variable, it is recommended to use the +`scipy.optimize.curve_fit` function via the `Curves` class. +In general, a one-dimensional curve fit function will follow the form given below. +By setting the curve fit function `f`, you define the shape of the curve and set +the order of the coefficients in `self.coeffs` since they are returned in the order they are +given in the function signature. +The `Curves.polynomal_eval` function is available to easily evaluate polynomial curves, but other +curve-types can be evaluated by simply plugging in the data points (`self.x`) to the fitted +function. + +```python +# Define a function for a prototype curve; this is where you define the shape of the curve +def f(x, a, b): + return a * x + b + +# Call the scipy.optimize.curve_fit function and get the coefficients as a Numpy array +# Note that `self.x` and `self.z` are given since the CostFunction class adds a y +# only when there are more independent variables. +self.coeffs = Curves.fit(f, self.x, self.z) + +# Evaluate the curve at the data points (self.x) +self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x) +``` + +A two-dimensional curve (surface) fit will typically follow a similar process, as should below. +For these types, it is recommended to use the `numpy.linalg.lstsq` function. +First, reshape the data into a new array with each element containing the three-dimensional +data points. +Then, stack the data into a column matrix in the form of the equation that you're implementing. +See the comments in the code block for more information. +Evaluate the curve at the data points (`self.x`, `self.y`) by stating the form of the curve +with the coefficients from the curve fit. + +```python + # Reshape the data into a new array with each element containing the three-dimensional data points + data_to_fit = np.array(list(zip(self.x, self.y, self.z))) + + # Stack the data into a column matrix in the form of the equation that you're implementing. + # Here, the equation is z = ax + by + c and data_to_fit[:,0] are the x values, + # data_to_fit[:,1] are the y values. The third column is all ones to account for the constant + # term. + A = np.c_[ + data_to_fit[:,0], + data_to_fit[:,1], + np.ones(data_to_fit.shape[0]) + ] + + # Fit the curve to the data; the data is the cost and these are always `self.z` which is data_to_fit[:,2] + self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) + + # Evaluate it on the same points as the input data + self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2] +``` + +Finally, save the coefficients to `self.coeffs`, save the evaluated curve to +`self._{curve_type}_{dimension}_curve`, and add the corresponding if-statements +in `CostFunction.plot` and `CostFunction.export`. + +```{code-cell} ipython3 +%matplotlib widget + +from copy import deepcopy +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from scipy import stats, optimize, linalg +import yaml + +from ORBIT import ( + ParametricManager, + load_config, +) + +import matplotlib as mpl +mpl.rcParams["figure.autolayout"] = True +``` + +## Configuration + +Replace any of these throughout the notebook to customize a cost model parameterization. + +```{code-cell} ipython3 +BASE_CONFIG = load_config("nrwal.yaml") + +DEPTHS = [i for i in range(5, 60, 5)] # Ocean depth in meters +MEAN_WIND_SPEED = [i for i in range(2, 20, 2)] # Mean wind speed in m/s +``` + +```{code-cell} ipython3 +orbit_to_nrwal_params = { + "site.depth": "depth", + "site.mean_windspeed": "mean_windspeed", # Not in NRWAL + "site.distance_to_landfall": "dist_s_to_l", + "mooring_system_design.draft_depth": "draft_depth", # Not in NRWAL + "array_system_design.touchdown_distance": "touchdown_distance", # Not in NRWAL + "array_system_design.floating_cable_depth": "floating_cable_depth", # Not in NRWAL +} +``` + +## Curve Fit Library + +```{code-cell} ipython3 +class Curves(): + """ + This class contains static methods for fitting data to various curve types. + Though they could exist outside of a class, consolidating them into a consistent + namespace allows for a simpler API throughout the script. + """ + + @staticmethod + def polynomial_eval(coeffs, data_points): + """ + This method evaluates a curve defined by a polynomial equation given a set of + coefficients and data points. + + Args: + coeffs (list): A list of coefficients for the curve. The order of the + coefficients should be from highest to lowest power. + data_points (list): A list of data points at which to evaluate the curve. + + Returns: + np.array: The curve evaluated at the given data points. + """ + curve = np.zeros_like(data_points) + for i, dp in enumerate(data_points): + + # This loop sums the terms of the polynomial + for j in range(len(coeffs)): + curve[i] += coeffs[j] * (dp ** (len(coeffs) - 1 - j)) + return curve + + @staticmethod + def fit(func, x, y, fit_check=False): + if x is pd.Series: + x = x.to_numpy(dtype=np.float64) + elif x is np.array: + x = x.astype(np.float64) + if y is pd.Series: + y = y.to_numpy(dtype=np.float64) + elif y is np.array: + y = y.astype(np.float64) + + popt, pcov, nfodict, mesg, ier = optimize.curve_fit(func, x, y, full_output=True) + + if fit_check: + print(f"mesg: {mesg}") + print(f"ier: {ier}") + print(f"Coefficients: {popt}") + # print(f"R-squared: {rvalue**2:.6f}") + + return popt +``` + +```{code-cell} ipython3 +class CostFunction(): + """ + This class is used to create the ORBIT parameterization, fit a curve, plot the curve, and + export the function to NRWAL format. Parameterizations are limited to up to two independent + variables. + """ + def __init__(self, config: dict, parameters: dict, results: dict): + """ + On initialization, the config, parameters, and results dictionaries are prepared for + use in ORBIT.ParametricManager. Additionally, the independent variables are extracted + into x and y (for two-variable parameterizations) and z is extracted as the dependent + variable. Whether the cost function is 3D or 2D is determined by the length of the + parameters variable. + + Args: + config (str): Configuration settings to added to the BASE_CONFIG or overwrite + in the BASE_CONFIG. This must include the `design_phases` config. + parameters (dict): Parameters to use with ORBIT.ParametricManager; maximum of two + parameters are supported. + results (dict): Results to use with ORBIT.ParametricManager; this must include only + one variable. + """ + self.is_3d = False + + # Other attributes + # self.parametric + # self.x + # self.y + # self.z + # self.x_variable + # self.y_variable + self._linear_1d_curve = None + self._quadratic_1d_curve = None + self._poly3_1d_curve = None + self._linear_2d_curve = None + self._quadratic_2d_curve = None + + # Start with a copy of the global BASE_CONFIG and update it with the configuration + # given to this class + self.config = deepcopy(BASE_CONFIG) + self.config.update(config) + + self.parameters = deepcopy(parameters) + if len(self.parameters) > 2: + raise ValueError("This class is limited to parameterizations with two variables.") + + # Puts the parameters and results settings into variables for use in parsing the ORBIT + # results and postprocessing the data + self.parameters = deepcopy(self.parameters) + _vars = list(self.parameters.keys()) + self.x_variable = _vars.pop(0) # NOTE: This assumes the first parameter is site.depth; it's not critical to functionality but good to keep in mind + if len(_vars) == 1: + self.is_3d = True + self.y_variable = _vars.pop() + self.z_variable = list(results.keys())[0] + + self.results = deepcopy(results) + if len(results) != 1: + raise ValueError("This class is limited to results with one variable") + + def run(self): + self.parametric = ParametricManager(self.config, self.parameters, self.results, product=True) + self.parametric.run() + + self.x = self.parametric.results[self.x_variable] + if self.is_3d: + self.y = self.parametric.results[self.y_variable] + self.z = self.parametric.results[self.z_variable] + + + ### --------- Curve fit functions --------- ### + + def linear_1d(self): + def f(x, a, b): + return a * x + b + self.coeffs = Curves.fit(f, self.x, self.z) + self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x) + + def quadratic_1d(self): + def f(x, a, b, c): + return a * x**2 + b * x + c + self.coeffs = Curves.fit(f, self.x, self.z) + self._quadratic_1d_curve = Curves.polynomial_eval(self.coeffs, self.x) + + def poly3_1d(self): + def f(x, a, b, c, d): + return a * x**3 + b * x**2 + c * x + d + self.coeffs = Curves.fit(f, self.x, self.z) + self._poly3_1d_curve = Curves.polynomial_eval(self.coeffs, self.x) + + # def logarithmic_1d(self): + # pass + + # def exponential_1d(self): + # pass + + def linear_2d(self): + data_to_fit = np.array(list(zip(self.x, self.y, self.z))) + + # Best-fit linear plane + A = np.c_[ + data_to_fit[:,0], + data_to_fit[:,1], + np.ones(data_to_fit.shape[0]) + ] + self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients + + # Evaluate it on the same points as the input data + self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2] + + def quadratic_2d(self): + data_to_fit = np.array(list(zip(self.x, self.y, self.z))) + + # best-fit quadratic curve + A = np.c_[ + np.ones(data_to_fit.shape[0]), + data_to_fit[:,:2], + np.prod(data_to_fit[:,:2], axis=1), + data_to_fit[:,:2]**2 + ] + self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) + + # Evaluate it on the same points as the input data + # This dot product is equivalent to the sum of the terms of the polynomial; + # np.c_[] is used to concatenate the arrays into the correct form for the dot product + # and C is the coefficients of the polynomial + self._quadratic_2d_curve = np.dot( + np.c_[ + np.ones(self.x.shape), + self.x, + self.y, + self.x*self.y, + self.x**2, + self.y**2 + ], + self.coeffs + ).reshape(self.x.shape) + + + ### --------- Plotting functions --------- ### + + def plot( + self, + ax, + plot_data: bool = False, + plot_curves: list[str] = [] + ): + if plot_data: + if self.is_3d: + ax.scatter(self.x, self.y, zs=self.z, zdir='z', label="Data") + else: + ax.scatter(self.x, self.z, label="Data") + + for curve in plot_curves: + + if curve == "linear_1d": + ax.plot(self.x, self._linear_1d_curve, label="Linear Fit") + + if curve == "quadratic_1d": + ax.plot(self.x, self._quadratic_1d_curve, label="Quadratic Fit") + + if curve == "poly3_1d": + ax.plot(self.x, self._poly3_1d_curve, label="Degree 3 Polynomial Fit") + + if curve == "linear_2d": + ax.plot_surface( + np.reshape(self.x, (len(DEPTHS), -1)), + np.reshape(self.y, (len(DEPTHS), -1)), + np.reshape(self._linear_2d_curve, (len(DEPTHS), -1)), + alpha=0.3, + label="Linear Fit" + ) + + if curve == "quadratic_2d": + ax.plot_surface( + np.reshape(self.x, (len(DEPTHS), -1)), + np.reshape(self.y, (len(DEPTHS), -1)), + np.reshape(self._quadratic_2d_curve, (len(DEPTHS), -1)), + alpha=0.3, + label="Quadratic Fit" + ) + + + ### --------- Export functions --------- ### + + def export(self, filename: str, key: str, comments: str = ""): + """ + This function writes the curve equation to a file for use in NRWAL. + + Args: + filename (str): The file to write the curve equation to. If the file exists, the + equation is appended to the end of the file. + key (str): The key to use in the NRWAL file for the curve equation. In the key-value + pair, this argument is the key and the value is the equation string. + """ + + x_var = orbit_to_nrwal_params[self.x_variable] + if self.is_3d: + y_var = orbit_to_nrwal_params[self.y_variable] + + F = "{:.1f}" + S = "{:s}" + if self._linear_1d_curve is not None: + # y = ax + b + equation_string = f"{F} * {S} + {F}".format(self.coeffs[0], x_var, self.coeffs[1]) + + if self._quadratic_1d_curve is not None: + # y = ax^2 + bx + c + equation_string = f"{F} * {S}**2 + {F} * {S} + {F}".format(self.coeffs[0], x_var, self.coeffs[1], x_var, self.coeffs[2]) + + if self._poly3_1d_curve is not None: + # y = ax^3 + bx^2 + cx + d + equation_string = ( + f"{F} * {S}**3" + f" + {F} * {S}**2" + f" + {F} * {S}" + f" + {F}".format( + self.coeffs[0], x_var, + self.coeffs[1], x_var, + self.coeffs[2], x_var, + self.coeffs[3] + ) + ) + + if self._linear_2d_curve is not None: + # z = ax + by + c + equation_string = f"{F} * {S} + {F} * {S} + {F}".format(self.coeffs[0], x_var, self.coeffs[1], y_var, self.coeffs[2]) + + if self._quadratic_2d_curve is not None: + # z = ax^2 + bxy + cy^2 + dx + ey + f + equation_string = ( + f"{F} * {S}**2" + f" + {F} * {S} * {S}" + f" + {F} * {S}**2" + f" + {F} * {S}" + f" + {F} * {S}" + f" + {F}".format( + self.coeffs[0], x_var, + self.coeffs[1], x_var, y_var, + self.coeffs[2], y_var, + self.coeffs[3], x_var, + self.coeffs[4], y_var, + self.coeffs[5] + ) + ) + + # nrwal_dict = {self.config["design_phases"][0]: equation_string} + nrwal_dict = {key: equation_string} + + with open(filename, "a") as f: + f.write("\n") + if comments: + f.write(f"# {comments}\n") + # f.write(f"# {self.config['design_phases'][0]}\n") + yaml.dump(nrwal_dict, f) + f.write(f"\n") + print(nrwal_dict) +``` + +# ORBIT Design Phase Cost Curves + ++++ + +## Monopile Substructure + +Independent variables: +- Water depth: impacts the mass of the monopile since it is fixed to the ocean floor +- Mean wind speed: impact the mass of the monopile by the load transferred from the turbine + +```{code-cell} ipython3 +cost_function = CostFunction( + config={"design_phases": ["MonopileDesign"]}, + parameters={ + "site.depth": DEPTHS, + "site.mean_windspeed": MEAN_WIND_SPEED, + }, + results={ + "monopile_unit_cost": lambda run: run.design_results["monopile"]["unit_cost"], + # "transition_piece_unit_cost": lambda run: run.design_results["transition_piece"]["unit_cost"], + } +) +cost_function.run() + +cost_function.linear_2d() +cost_function.quadratic_2d() + +fig = plt.figure() +ax = fig.add_subplot(projection='3d') +ax.set_title("Monopile Substructure") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Mean wind speed (m/s)") +ax.set_zlabel("Cost ($)") +cost_function.plot(ax, plot_data=True) +cost_function.plot(ax, plot_curves=["linear_2d", "quadratic_2d"]) +ax.legend() + +cost_function.export("substructure.yaml", "substructure_17MW") +``` + +## Semi-Submersible Substructure + +Since the semisubmersible is a floating structure, the water depth does not impact the mass +of the structure. +The mean wind speed does impact the mass of the structure by the load transferred from the +turbine, but this is not included in the design phase cost model directly. +The plot here shows that the cost is constant with respect to the water depth. + +```{code-cell} ipython3 +cost_function = CostFunction( + config={"design_phases": ["SemiSubmersibleDesign"]}, + parameters={ + "site.depth": DEPTHS, + }, + results={ + "substructure_unit_cost": lambda run: run.design_results["substructure"]["unit_cost"], + } +) +cost_function.run() + +cost_function.linear_1d() + +fig = plt.figure() +ax = fig.add_subplot() +ax.set_title("Semisubmersible Substructure") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cost ($)") +cost_function.plot(ax, plot_data=True) +cost_function.plot(ax, plot_curves=["linear_1d"]) +ax.legend() +``` + +## Mooring System + +This block creates a cost model for each type of mooring system. +For all types, the line length is a function of water depth. +For TLP systems, line length is the difference between the water depth and the draft. +For SemiTaut systems, line length is the sum of rope length and chain length. +Rope length is defined from a fixed relationship for depth and rope lengths. +Chain length is also defined from a fixed relationship for depth and chain diameter. +While the semi-taut system line length is dependent on rope length and chain length, the parameters +are fixed and depend on water depth so they are not included in this parameterization. + +```{code-cell} ipython3 +design_phase = "MooringSystemDesign" +results = { + "mooring_system_system_cost": lambda run: run.design_results["mooring_system"]["system_cost"], +} + +# Catenary mooring system +cost_catenary = CostFunction( + config={ + "design_phases": [design_phase], + "mooring_system_design": {"mooring_type": "Catenary"} + }, + parameters={ + "site.depth": DEPTHS, + }, + results=results +) +cost_catenary.run() + +# Tension Leg Platform (TLP) mooring system +cost_tlp = CostFunction( + config={ + "design_phases": [design_phase], + "mooring_system_design": {"mooring_type": "TLP"} + }, + parameters={ + "site.depth": DEPTHS, + "mooring_system_design.draft_depth": [i for i in range(5, 100, 5)] # Draft depth 5-100 meters + }, + results=results +) +cost_tlp.run() + +# Semi-taut mooring system +cost_semitaut = CostFunction( + config={ + "design_phases": [design_phase], + "mooring_system_design": {"mooring_type": "SemiTaut"} + }, + parameters={ + "site.depth": DEPTHS, + }, + results=results +) +cost_semitaut.run() + +## Fit the data to a curve +cost_catenary.linear_1d() +cost_tlp.linear_2d() +cost_semitaut.linear_1d() + +## Plot the ORBIT data and curve fits +fig = plt.figure() + +ax = fig.add_subplot(2, 2, 1) +ax.set_title("Catenary") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cost ($)") +cost_catenary.plot(ax, plot_data=True) +cost_catenary.plot(ax, plot_curves=["linear_1d"]) + +ax = fig.add_subplot(2, 2, 2, projection='3d') +ax.set_title("TLP") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Draft depth (m)") +ax.set_zlabel("Cost ($)") +cost_tlp.plot(ax, plot_data=True) +cost_tlp.plot(ax, plot_curves=["linear_2d"]) + +ax = fig.add_subplot(2, 2, 3) +ax.set_title("Semi-Taut") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cost ($)") +cost_semitaut.plot(ax, plot_data=True) +cost_semitaut.plot(ax, plot_curves=["linear_1d"]) + +cost_catenary.export("mooring_system.yaml", "catenary") +cost_tlp.export("mooring_system.yaml", "tlp") +cost_semitaut.export("mooring_system.yaml", "semitaut") +``` + +## Array System + +The array system cost is entirely dependent on the cable length. +The cable length is a function of some fixed plant parameters and the following spatially +dependent parameters: +- water depth +- touchdown distance +- floating cable depth + +```{code-cell} ipython3 +# First plot cost as a function of depth, touchdown_distance, and floating_cable_depth to get a +# sense for the 1d relationships + +design_phase = "ArraySystemDesign" +results = { + "array_system_system_cost": lambda run: run.design_results["array_system"]["system_cost"], +} + +# Water depth +cost_depth = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "site.depth": DEPTHS, + }, + results=results +) +cost_depth.run() + +# Touchdown distance +cost_touchdown_distance = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "array_system_design.touchdown_distance": [i for i in range(0, 100, 10)], + }, + results=results +) +cost_touchdown_distance.run() + +# Floating cable depth +cost_cable_depth = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "array_system_design.floating_cable_depth": DEPTHS, + }, + results=results +) +cost_cable_depth.run() + +cost_depth.linear_1d() +cost_touchdown_distance.quadratic_1d() +cost_cable_depth.linear_1d() +cost_cable_depth.quadratic_1d() +cost_cable_depth.poly3_1d() + +fig = plt.figure() +ax = fig.add_subplot(2, 2, 1) +ax.set_title("Depth") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cost ($)") +cost_depth.plot(ax, plot_data=True) +cost_depth.plot(ax, plot_curves=["linear_1d"]) + +ax = fig.add_subplot(2, 2, 2) +ax.set_title("Touchdown Distance") +ax.set_xlabel("Touchdown Distance (m)") +ax.set_ylabel("Cost ($)") +cost_touchdown_distance.plot(ax, plot_data=True) +cost_touchdown_distance.plot(ax, plot_curves=["quadratic_1d"]) + +ax = fig.add_subplot(2, 2, 3) +ax.set_title("Floating Depth") +ax.set_xlabel("Floating Depth (m)") +ax.set_ylabel("Cost ($)") +cost_cable_depth.plot(ax, plot_data=True) +cost_cable_depth.plot(ax, plot_curves=["linear_1d", "quadratic_1d", "poly3_1d"]) +``` + +```{code-cell} ipython3 +# Then create functions of two variables. +# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes +# some time to run. + +design_phase = "ArraySystemDesign" +results = { + "array_system_system_cost": lambda run: run.design_results["array_system"]["system_cost"], +} + +# Water depth vs touchdown distance +cost_depth_touchdown_distance = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "site.depth": DEPTHS, + "array_system_design.touchdown_distance": [i for i in range(0, 100, 10)], + }, + results=results +) +cost_depth_touchdown_distance.run() + +# Water depth vs cable depth +cost_depth_cabledepth = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "site.depth": DEPTHS, + "array_system_design.floating_cable_depth": DEPTHS, + }, + results=results +) +cost_depth_cabledepth.run() + +# Touchdown distance vs cable depth +cost_touchdown_cabledepth = CostFunction( + config={ + "design_phases": [design_phase], + }, + parameters={ + "array_system_design.floating_cable_depth": DEPTHS, + "array_system_design.touchdown_distance": [i for i in range(0, 100, 10)], + }, + results=results +) +cost_touchdown_cabledepth.run() +``` + +```{code-cell} ipython3 +# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes +# some time to run. + +cost_depth_touchdown_distance.quadratic_2d() +cost_depth_cabledepth.quadratic_2d() +cost_touchdown_cabledepth.quadratic_2d() + +fig = plt.figure() +ax = fig.add_subplot(2, 2, 1, projection='3d') +ax.set_title("Depth vs Touchdown Distance") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Touchdown Distance (m)") +ax.set_zlabel("Cost ($)") +cost_depth_touchdown_distance.plot(ax, plot_data=True) +cost_depth_touchdown_distance.plot(ax, plot_curves=["quadratic_2d"]) + +ax = fig.add_subplot(2, 2, 2, projection='3d') +ax.set_title("Depth v Cable Depth") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cable Depth (m)") +ax.set_zlabel("Cost ($)") +cost_depth_cabledepth.plot(ax, plot_data=True) +cost_depth_cabledepth.plot(ax, plot_curves=["quadratic_2d"]) + +ax = fig.add_subplot(2, 2, 3, projection='3d') +ax.set_title("Touchdown Distance v Floating Depth") +ax.set_xlabel("Touchdown Distance (m)") +ax.set_ylabel("Floating Depth (m)") +ax.set_zlabel("Cost ($)") +cost_touchdown_cabledepth.plot(ax, plot_data=True) +cost_touchdown_cabledepth.plot(ax, plot_curves=["quadratic_2d"]) +``` + +```{code-cell} ipython3 +cost_touchdown_cabledepth.export("array_system.yaml", "floating") +``` + +## Export System + +This block creates a cost model for systems with high voltage alternating current (HVAC) and +high voltage direct current (HVDC) cables. + +Independent variables: +- site.distance_to_landfall +- Depth + +```{code-cell} ipython3 +design_phase = "ExportSystemDesign" +results = { + "export_system_system_cost": lambda run: run.design_results["export_system"]["system_cost"], +} + +## Run ORBIT for each hvac and hvdc export system types + +cost_hvac = CostFunction( + config={ + "design_phases": [design_phase], + "export_system_design": {"cables": "XLPE_1000mm_220kV"}, + }, + parameters={ + "site.depth": DEPTHS, + "site.distance_to_landfall": [i for i in range(0, 400, 10)], + }, + results=results +) +cost_hvac.run() + +cost_hvdc = CostFunction( + config={ + "design_phases": [design_phase], + "export_system_design": {"cables": "HVDC_2000mm_320kV"}, + }, + parameters={ + "site.depth": DEPTHS, + "site.distance_to_landfall": [i for i in range(0, 400, 10)], + }, + results=results +) +cost_hvdc.run() + +cost_hvac.linear_2d() +cost_hvdc.linear_2d() + +## Plot the ORBIT data and curve fits + +fig = plt.figure() + +ax = fig.add_subplot(1, 2, 1, projection='3d') +ax.set_title("HVAC") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Distance to Landfall (m)") +ax.set_zlabel("Cost ($)") +cost_hvac.plot(ax, plot_data=True) +cost_hvac.plot(ax, plot_curves=["linear_2d"]) + +ax = fig.add_subplot(1, 2, 2, projection='3d') +ax.set_title("HVDC") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Distance to Landfall (m)") +ax.set_zlabel("Cost ($)") +cost_hvdc.plot(ax, plot_data=True) +cost_hvdc.plot(ax, plot_curves=["linear_2d"]) + + +multiline_comment = "\n# ".join([ + "The floating HVAC mooring system is ", + "special because it's the only one that ", + "is like it is." +]) +cost_hvac.export("export_system.yaml", "floating_hvac", comments=multiline_comment) + +singleline_comment = "HVDC export system" +cost_hvdc.export("export_system.yaml", "floating_hvdc", comments=singleline_comment) +``` + +## Offshore Floating Substation + +This component is not a function of a spatially varying parameter, but it is included to complete +the export of the capex breakdown components. + +```{code-cell} ipython3 +cost_function = CostFunction( + config={"design_phases": ["OffshoreFloatingSubstationDesign"]}, + parameters={ + "site.depth": DEPTHS, + }, + results={ + "offshore_substation_substructure": lambda run: run.design_results["offshore_substation_substructure"]["unit_cost"], + } +) +cost_function.run() + +cost_function.linear_1d() + +fig = plt.figure() +ax = fig.add_subplot() +ax.set_title("Offshore Floating Substation") +ax.set_xlabel("Depth (m)") +ax.set_ylabel("Cost ($)") +cost_function.plot(ax, plot_data=True) +cost_function.plot(ax, plot_curves=["linear_1d"]) +ax.legend() + +cost_function.export("oss.yaml", "oss_substructure") +``` diff --git a/docs/topical_guides/custom_array.md b/docs/topical_guides/custom_array.md index 49c3c9a3..84eac5a6 100644 --- a/docs/topical_guides/custom_array.md +++ b/docs/topical_guides/custom_array.md @@ -133,7 +133,7 @@ df.sort_values(by=["String", "Order"]) In this first case, we assume little knowledge of what data are required for the CSV, and walk through generating a sample CSV. We will use the -[`library/cables/example_custom_array_no_data.csv`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_no_data.csv) +[`library/project/config/example_custom_array_no_data.csv`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_no_data.csv) configuration for this example. First, we need to load in the configuration dictionary. Then, we will create a starter file in @@ -174,7 +174,7 @@ information regarding the actual cable lengths or the cable burial speeds for ea we will demonstrate using the standard straight-line distance and default cable burying rates. This case will rely on the -[`library/cables/example_custom_array_simple.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_simple.yaml) configuration. +[`library/project/config/example_custom_array_simple.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/project/config/cables/example_custom_array_simple.yaml) configuration. ```{code-cell} ipython3 config = library.extract_library_specs("config", "example_custom_array_simple") @@ -232,7 +232,7 @@ df Using the distance-based location data requires us to set `distance` to True in the `array_system_design` section of the configuration. This change is shown below in the -[`library/cables/example_custom_array_simple_distance_based.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_simple_distance_based.yaml) configuration. +[`library/project/config/example_custom_array_simple_distance_based.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_simple_distance_based.yaml) configuration. ```{code-cell} ipython3 config = library.extract_library_specs("config", "example_custom_array_simple_distance_based") @@ -271,7 +271,7 @@ will be applied to all cable sections, so it's important to account for this whe additional cable lengths. In the -[`library/cables/example_custom_array_exclusions.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_exclusions.yaml) +[`library/project/config/example_custom_array_exclusions.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_exclusions.yaml) configuration, a 4.8% exclusion is applied to the entire farm. When plotting farms with exclusion zones, they will not be shown since we are not mapping the true cable path, simply the connections between turbines. In this case, we can also a modest increase in cabling costs resulting from the @@ -342,7 +342,7 @@ Using cases 2, 3, 4, and 5 we will demonstrate the project-wide effects from dif ### Setting Up The Cases Using the -[`library/cables/example_array_cable_install.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_array_cable_install.yaml) +[`library/project/config/example_array_cable_install.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_array_cable_install.yaml) configuration as a base configuration, we'll create a new configuration for each of the cases using each case's `design_result` as the `array_system` values. @@ -390,7 +390,7 @@ for name, simulation in zip(names, simulations): We will now incorporate the desgin settings from [Case 5](#case_5) to demonstrate incorporation of the custom array design tooling into `ProjectManager`. This example will use the -[`library/cables/example_custom_array_project_manager.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_project_manager.yaml) +[`library/project/config/example_custom_array_project_manager.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_project_manager.yaml) configuration. ```{code-cell} ipython3 diff --git a/docs/topical_guides/supply_chains.md b/docs/topical_guides/supply_chains.md index aab53ea3..422e0d12 100644 --- a/docs/topical_guides/supply_chains.md +++ b/docs/topical_guides/supply_chains.md @@ -48,7 +48,7 @@ jacket design model in ORBIT, so we must provide the basic jacket parameterizati design result. ```{code-cell} ipython3 -base_jacket_config = load_config("configs/example_fixed_project.yaml") +base_jacket_config = load_config(example_path / "configs/example_fixed_project.yaml") base_jacket_config["jacket"] = { "diameter": 10, "height": 100, @@ -173,29 +173,29 @@ ax = fig.add_subplot(111) case2_installs_neg = case2_installs.copy() case2_installs_neg["number"] *= -1 -case2_total = pd.concat([case2_deliveries, case2_installs_neg]).sort_values('time') -case2_total['storage'] = case2_total['number'].cumsum() +case2_total = pd.concat([case2_deliveries, case2_installs_neg]).sort_values("time") +case2_total["storage"] = case2_total["number"].cumsum() case3_installs_neg = case3_installs.copy() case3_installs_neg["number"] *= -1 -case3_total = pd.concat([case3_deliveries, case3_installs_neg]).sort_values('time') -case3_total['storage'] = case3_total['number'].cumsum() +case3_total = pd.concat([case3_deliveries, case3_installs_neg]).sort_values("time") +case3_total["storage"] = case3_total["number"].cumsum() ax.plot( - case2_total['time'], - case2_total['storage'], + case2_total["time"], + case2_total["storage"], label="Storage Required - Slow Fabrication" ) ax.plot( - case3_total['time'], - case3_total['storage'], + case3_total["time"], + case3_total["storage"], label="Storage Required - Increased Fabrication" ) ax.set_xlim(0, ax.get_xlim()[1]) # ax.set_ylim(0, 5) -ax.axhline(4, ls="--", lw=0.5, c='k', label="Theoretical Port Storage Limit) +ax.axhline(4, ls="--", lw=0.5, c="k", label="Theoretical Port Storage Limit") ax.set_xlabel("Simulation Time (h)") ax.set_ylabel("Substructures") diff --git a/docs/tutorials/parametric_manager.md b/docs/tutorials/parametric_manager.md index bfb82e53..47fd49d1 100644 --- a/docs/tutorials/parametric_manager.md +++ b/docs/tutorials/parametric_manager.md @@ -40,6 +40,8 @@ config["turbine"] = "15MW_generic" weather = pd.read_csv(example_dir / "data/example_weather.csv").set_index("datetime") ``` +## Setting Up The Parameterized Inputs + For all the non-parameterized inputs, they can be left as-is. However, all parameterized variables should be provided in a separate dictionary as a list. Because ORBIT uses the `benedict` library for more streamlined dictionary access, nested keys can be represented using dot-notation as is @@ -49,7 +51,6 @@ shown below where we parameterize the key siting details. params = { "site.depth": list(range(10, 71, 10)), "site.distance": list(range(20, 201, 20)), - "site.distance_to_landfall": [60, 80, 100], } ``` @@ -64,6 +65,8 @@ results = { } ``` +## Previewing and Running The Model + If many parameters are configured, it will take a longer time to run, especially if a weather profile is provided and `product=True`. To get an idea of the total run time, use the `preview` method, as seen below. @@ -87,7 +90,7 @@ The results are saved as a pandas DataFrame in the `results` attribute where eac different scenario run and the columns are labeled with with the various parameters and results values that were configured. -## Plotting +## Plotting The Results It is more convenient to plot the results of the `ParametricManager` than it is to view them as a table, especially with a large number of parameters. First, we will create a matrix of results diff --git a/examples/available_outputs.ipynb b/examples/available_outputs.ipynb index 9a8d2fac..ecc9506f 100644 --- a/examples/available_outputs.ipynb +++ b/examples/available_outputs.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "72de6548", + "id": "2ff27af5", "metadata": {}, "source": [ "(outputs-tutorial)=\n", @@ -23,7 +23,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "1d944125", + "id": "eb1ba216", "metadata": {}, "outputs": [ { @@ -54,7 +54,7 @@ }, { "cell_type": "markdown", - "id": "d1148e2a", + "id": "1498686a", "metadata": {}, "source": [ "## Project Details\n", @@ -68,7 +68,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "fdd629ec", + "id": "624e5aa6", "metadata": {}, "outputs": [ { @@ -142,7 +142,7 @@ }, { "cell_type": "markdown", - "id": "ebcd2f59", + "id": "b9e74f9e", "metadata": {}, "source": [ "### Project Parameterizaions\n", @@ -158,7 +158,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "f6f31b27", + "id": "321f305d", "metadata": {}, "outputs": [ { @@ -181,7 +181,7 @@ }, { "cell_type": "markdown", - "id": "3529a6e0", + "id": "109bd3e9", "metadata": {}, "source": [ "### Event Timing\n", @@ -194,7 +194,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "ffb35771", + "id": "76e2354a", "metadata": {}, "outputs": [ { @@ -213,7 +213,7 @@ }, { "cell_type": "markdown", - "id": "46e7a615", + "id": "9c889ab7", "metadata": {}, "source": [ "## All Outputs At Once\n", @@ -230,7 +230,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "744d62c5", + "id": "03db516d", "metadata": {}, "outputs": [ { @@ -351,7 +351,7 @@ }, { "cell_type": "markdown", - "id": "da04549b", + "id": "d4350ae5", "metadata": {}, "source": [ "## CapEx\n", @@ -375,7 +375,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "fb740ed4", + "id": "6d7b47f7", "metadata": {}, "outputs": [ { @@ -394,7 +394,7 @@ }, { "cell_type": "markdown", - "id": "d6c62f3d", + "id": "ec008904", "metadata": {}, "source": [ "### Categorical CapEx Breakdowns\n", @@ -407,7 +407,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "46cb02f6", + "id": "001627ca", "metadata": {}, "outputs": [ { @@ -439,7 +439,7 @@ }, { "cell_type": "markdown", - "id": "29d5439f", + "id": "a026b617", "metadata": {}, "source": [ "Like in the previous examples, the `capex_breakdown_per_kw` will provide each category's associated\n", @@ -449,7 +449,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "cbc2f84b", + "id": "09ef6c92", "metadata": {}, "outputs": [ { @@ -481,7 +481,7 @@ }, { "cell_type": "markdown", - "id": "5aac8851", + "id": "cfb914e4", "metadata": {}, "source": [ "### BOS CapEx\n", @@ -493,7 +493,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "b89fbb52", + "id": "b7654950", "metadata": {}, "outputs": [ { @@ -512,7 +512,7 @@ }, { "cell_type": "markdown", - "id": "e59284f9", + "id": "ae9f4a41", "metadata": {}, "source": [ "### System CapEx\n", @@ -527,7 +527,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "79de4eed", + "id": "b85da225", "metadata": {}, "outputs": [ { @@ -546,7 +546,7 @@ }, { "cell_type": "markdown", - "id": "fa329bc4", + "id": "0c18adf3", "metadata": {}, "source": [ "To view the individual component system costs, users can inspect the `system_costs` dictionary where\n", @@ -556,7 +556,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "5a636796", + "id": "8428f726", "metadata": {}, "outputs": [ { @@ -578,7 +578,7 @@ }, { "cell_type": "markdown", - "id": "d86ce7b9", + "id": "889c09e9", "metadata": {}, "source": [ "### Installation Capex\n", @@ -594,7 +594,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "3fd1d588", + "id": "58111600", "metadata": {}, "outputs": [ { @@ -613,7 +613,7 @@ }, { "cell_type": "markdown", - "id": "f116b847", + "id": "f46e212f", "metadata": {}, "source": [ "To view the individual component installation costs, users can inspect the `installation_costs`\n", @@ -624,7 +624,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "17a27e24", + "id": "fc3bd0fa", "metadata": {}, "outputs": [ { @@ -647,7 +647,7 @@ }, { "cell_type": "markdown", - "id": "2cd9fa46", + "id": "c36d5c05", "metadata": {}, "source": [ "### Turbine CapEx\n", @@ -659,7 +659,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "75bf8fbd", + "id": "037c1ac2", "metadata": {}, "outputs": [ { @@ -678,7 +678,7 @@ }, { "cell_type": "markdown", - "id": "011184eb", + "id": "b1121cc5", "metadata": {}, "source": [ "### Project CapEx\n", @@ -693,7 +693,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "57b617a5", + "id": "6db74098", "metadata": {}, "outputs": [ { @@ -712,7 +712,7 @@ }, { "cell_type": "markdown", - "id": "95257081", + "id": "bf83a824", "metadata": {}, "source": [ "### Soft CapEx\n", @@ -727,7 +727,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "79267541", + "id": "baf878ec", "metadata": {}, "outputs": [ { @@ -746,7 +746,7 @@ }, { "cell_type": "markdown", - "id": "076e07d0", + "id": "17743637", "metadata": {}, "source": [ "The soft CapEx can also be broken down using both the `soft_capex_breakdown` and the `capex_detailed_soft_capex_breakdown`, which also provide a capacity-noramlized variation by adding\n", @@ -758,7 +758,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "d83813da", + "id": "12057ba4", "metadata": {}, "outputs": [ { @@ -782,7 +782,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "8af1b169", + "id": "ea3fd05f", "metadata": {}, "outputs": [ { @@ -819,7 +819,7 @@ }, { "cell_type": "markdown", - "id": "d302cb00", + "id": "bbb1c9bb", "metadata": {}, "source": [ "The soft CapEx values are also available as independent values:\n", @@ -835,7 +835,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "e2f890cb", + "id": "14cd601c", "metadata": {}, "outputs": [ { @@ -862,7 +862,7 @@ }, { "cell_type": "markdown", - "id": "5ec81560", + "id": "dff9f663", "metadata": {}, "source": [ "### All Other CapEx Categories\n", @@ -879,7 +879,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "a5b84c69", + "id": "faed7724", "metadata": {}, "outputs": [ { @@ -898,7 +898,7 @@ }, { "cell_type": "markdown", - "id": "f7ea395a", + "id": "dfae7916", "metadata": {}, "source": [ "#### Onshore Substation CapEx\n", @@ -909,7 +909,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "49b20214", + "id": "e2a55a2b", "metadata": {}, "outputs": [ { @@ -928,7 +928,7 @@ }, { "cell_type": "markdown", - "id": "0ae7657d", + "id": "e4cb433a", "metadata": {}, "source": [ "#### Overnight CapEx\n", @@ -939,7 +939,7 @@ { "cell_type": "code", "execution_count": 22, - "id": "e3a82336", + "id": "500d1108", "metadata": {}, "outputs": [ { @@ -956,7 +956,7 @@ }, { "cell_type": "markdown", - "id": "a0eb444d", + "id": "33e2d0a4", "metadata": {}, "source": [ "## Logging\n", @@ -974,7 +974,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "c0287378", + "id": "c6ee40bf", "metadata": {}, "outputs": [ { @@ -1002,7 +1002,7 @@ }, { "cell_type": "markdown", - "id": "36e977ea", + "id": "57ef770a", "metadata": {}, "source": [ "The `project_logs` provides a list of the when a component installation was completed using the\n", @@ -1032,7 +1032,7 @@ { "cell_type": "code", "execution_count": 24, - "id": "d58074e8", + "id": "d2d9e0d9", "metadata": {}, "outputs": [ { @@ -1120,7 +1120,7 @@ }, { "cell_type": "markdown", - "id": "cfd95776", + "id": "063c2b3b", "metadata": {}, "source": [ "Below, we can see the installation timing is not quite realistic given the WTIV is used for the\n", @@ -1132,7 +1132,7 @@ { "cell_type": "code", "execution_count": 25, - "id": "e751ccf2", + "id": "8df9e57c", "metadata": {}, "outputs": [ { @@ -1170,7 +1170,7 @@ }, { "cell_type": "markdown", - "id": "e56facf8", + "id": "ae9db786", "metadata": {}, "source": [ "### Detailed Event Timing\n", @@ -1183,7 +1183,7 @@ { "cell_type": "code", "execution_count": 26, - "id": "1f14e0c5", + "id": "e47033c0", "metadata": {}, "outputs": [ { @@ -1367,7 +1367,7 @@ }, { "cell_type": "markdown", - "id": "bb01e627", + "id": "9eb26864", "metadata": {}, "source": [ "Using the data frame we can filter produce vessel timing summaries for a single phase or a single\n", @@ -1382,7 +1382,7 @@ { "cell_type": "code", "execution_count": 27, - "id": "5e378669", + "id": "1cc3660c", "metadata": {}, "outputs": [ { @@ -1390,13 +1390,13 @@ "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -1407,91 +1407,91 @@ " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", "
  durationcostdurationcost
agent
WTIVBolt TP200.003,333,333.33WTIVBolt TP200.003,333,333.33
Crane Reequip100.001,666,666.67Crane Reequip100.001,666,666.67
Drive Monopile75.001,250,000.00Drive Monopile75.001,250,000.00
Fasten Monopile600.0010,000,000.00Fasten Monopile600.0010,000,000.00
Fasten Transition Piece400.006,666,666.67Fasten Transition Piece400.006,666,666.67
Jackdown15.83263,888.89Jackdown15.83263,888.89
Jackup15.83263,888.89Jackup15.83263,888.89
Lower Monopile0.162,708.33Lower Monopile0.162,708.33
Lower TP50.00833,333.33Lower TP50.00833,333.33
Mobilize168.002,800,000.00Mobilize168.002,800,000.00
Position Onsite100.001,666,666.67Position Onsite100.001,666,666.67
Release Monopile150.002,500,000.00Release Monopile150.002,500,000.00
Release Transition Piece100.001,666,666.67Release Transition Piece100.001,666,666.67
RovSurvey50.00833,333.33RovSurvey50.00833,333.33
Transit235.603,926,666.67Transit235.603,926,666.67
Upend Monopile30.46507,730.71Upend Monopile30.46507,730.71
\n" ], "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1513,7 +1513,7 @@ }, { "cell_type": "markdown", - "id": "f777eaea", + "id": "d8f07cc1", "metadata": {}, "source": [ "## Cash Flow and Net Present Value\n", @@ -1534,7 +1534,7 @@ { "cell_type": "code", "execution_count": 28, - "id": "fc05bd45", + "id": "40fd26e2", "metadata": {}, "outputs": [ { @@ -1543,13 +1543,6 @@ "text": [ "NPV: $1,493.98 (millions, USD)\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] } ], "source": [ @@ -1558,7 +1551,7 @@ }, { "cell_type": "markdown", - "id": "b9f4e828", + "id": "2df62d9e", "metadata": {}, "source": [ "Below, we highlight the first 12 months of the project cash flow. In the 10th month we can see that\n", @@ -1569,7 +1562,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "62f58e96", + "id": "7e83f921", "metadata": {}, "outputs": [ { @@ -1577,106 +1570,106 @@ "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 monthly_opexmonthly_expensesmonthly_revenuecash_flowmonthly_opexmonthly_expensesmonthly_revenuecash_flow
00.0046,066,981.590.00-46,066,981.5900.0046,066,981.590.00-46,066,981.59
10.0035,066,816.850.00-35,066,816.8510.0035,066,816.850.00-35,066,816.85
20.0033,022,561.610.00-33,022,561.6120.0033,022,561.610.00-33,022,561.61
30.0027,488,874.200.00-27,488,874.2030.0027,488,874.200.00-27,488,874.20
44,500,000.0030,140,360.568,409,600.00-21,730,760.5644,500,000.0030,140,360.568,409,600.00-21,730,760.56
56,300,000.0019,454,128.7711,773,440.00-7,680,688.7756,300,000.0019,454,128.7711,773,440.00-7,680,688.77
67,200,000.0015,594,619.2313,455,360.00-2,139,259.2367,200,000.0015,594,619.2313,455,360.00-2,139,259.23
77,500,000.0014,520,561.7214,016,000.00-504,561.7277,500,000.0014,520,561.7214,016,000.00-504,561.72
87,500,000.008,078,377.0114,016,000.005,937,622.9987,500,000.008,078,377.0114,016,000.005,937,622.99
97,500,000.007,500,000.0014,016,000.006,516,000.0097,500,000.007,500,000.0014,016,000.006,516,000.00
107,500,000.007,500,000.0014,016,000.006,516,000.00107,500,000.007,500,000.0014,016,000.006,516,000.00
117,500,000.007,500,000.0014,016,000.006,516,000.00117,500,000.007,500,000.0014,016,000.006,516,000.00
\n" ], "text/plain": [ - "" + "" ] }, "execution_count": 29, diff --git a/examples/cable_installation.ipynb b/examples/cable_installation.ipynb index c6e80474..daa0fb3e 100644 --- a/examples/cable_installation.ipynb +++ b/examples/cable_installation.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "7f1c7c2c", + "id": "63386374", "metadata": {}, "source": [ "# Cable Laying and Burying\n", @@ -15,7 +15,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "bf8ca019", + "id": "23051ed0", "metadata": {}, "outputs": [], "source": [ @@ -28,7 +28,7 @@ }, { "cell_type": "markdown", - "id": "76354809", + "id": "20d3d8d3", "metadata": {}, "source": [ "Below, we set up a base configuration using an imagined cable and sections (25 each of 1km and 2km cable sections) designed for simplicity." @@ -37,7 +37,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "0a607a62", + "id": "359e9b09", "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,7 @@ }, { "cell_type": "markdown", - "id": "786ed6e0", + "id": "41308710", "metadata": {}, "source": [ "## Single Cable Laying and Burying Process\n", @@ -71,7 +71,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "e5ad6587", + "id": "aada4950", "metadata": {}, "outputs": [ { @@ -92,7 +92,7 @@ }, { "cell_type": "markdown", - "id": "2a7f9980", + "id": "3b18166b", "metadata": {}, "source": [ "## Separate Cable Laying and Burying Processes\n", @@ -110,7 +110,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "12c1634f", + "id": "bc638c30", "metadata": {}, "outputs": [], "source": [ @@ -124,7 +124,7 @@ }, { "cell_type": "markdown", - "id": "9bb884fd", + "id": "2750f34b", "metadata": {}, "source": [ "## Including a Trenching Vessel\n", @@ -138,7 +138,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "409698b6", + "id": "d4f637d7", "metadata": {}, "outputs": [], "source": [ @@ -154,7 +154,7 @@ }, { "cell_type": "markdown", - "id": "9084601c", + "id": "f9c69249", "metadata": {}, "source": [ "## Viewing the results\n", @@ -166,7 +166,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "78ef1baa", + "id": "be805dfc", "metadata": {}, "outputs": [ { @@ -391,7 +391,7 @@ }, { "cell_type": "markdown", - "id": "7cef009a", + "id": "3a98b62e", "metadata": {}, "source": [ "Now, we demonstrate the separate process by combining the separate laying and burying steps taken\n", @@ -404,7 +404,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "552f5267", + "id": "b22592fe", "metadata": {}, "outputs": [ { @@ -665,7 +665,7 @@ }, { "cell_type": "markdown", - "id": "53a4bf06", + "id": "df6233cd", "metadata": {}, "source": [ "Similar to the above, when we add trenching as a separate step, we have three discrete stages to\n", @@ -675,7 +675,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "c78cc13b", + "id": "cd44470c", "metadata": {}, "outputs": [ { diff --git a/examples/custom_array.ipynb b/examples/custom_array.ipynb index 78c56982..5fe1a5ca 100644 --- a/examples/custom_array.ipynb +++ b/examples/custom_array.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "bb87ebba", + "id": "d170c98c", "metadata": {}, "source": [ "(custom-array-layou)=\n", @@ -24,7 +24,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "93015a5f", + "id": "a1b4f1b6", "metadata": {}, "outputs": [ { @@ -58,7 +58,7 @@ }, { "cell_type": "markdown", - "id": "19e8efdf", + "id": "e1e687e5", "metadata": {}, "source": [ "## Contents\n", @@ -90,7 +90,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "5a7ea0ee", + "id": "a69025f3", "metadata": {}, "outputs": [ { @@ -114,7 +114,7 @@ }, { "cell_type": "markdown", - "id": "a448ecf8", + "id": "738ff218", "metadata": {}, "source": [ "### Key Differences In A Custom Layout Configuration\n", @@ -135,7 +135,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "2c28f55d", + "id": "e2a6565d", "metadata": {}, "outputs": [ { @@ -232,7 +232,7 @@ }, { "cell_type": "markdown", - "id": "a8c60a14", + "id": "7252d97a", "metadata": {}, "source": [ "### Custom Array Layout CSV Explanation\n", @@ -265,7 +265,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "86611b6b", + "id": "3d83c8c5", "metadata": {}, "outputs": [ { @@ -480,7 +480,7 @@ }, { "cell_type": "markdown", - "id": "7a04891a", + "id": "99392f37", "metadata": {}, "source": [ "(case_1)=\n", @@ -488,7 +488,7 @@ "\n", "In this first case, we assume little knowledge of what data are required for the CSV, and walk\n", "through generating a sample CSV. We will use the\n", - "[`library/cables/example_custom_array_no_data.csv`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_no_data.csv)\n", + "[`library/project/config/example_custom_array_no_data.csv`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_no_data.csv)\n", "configuration for this example.\n", "\n", "First, we need to load in the configuration dictionary. Then, we will create a starter file in\n", @@ -498,7 +498,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "b9c9bb8b", + "id": "43e3fde9", "metadata": {}, "outputs": [ { @@ -534,7 +534,7 @@ }, { "cell_type": "markdown", - "id": "7dfa3b0e", + "id": "7dab9a89", "metadata": {}, "source": [ "There are a few items worth noting in the layout:\n", @@ -550,7 +550,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "e12e739a", + "id": "53c70c5b", "metadata": {}, "outputs": [], "source": [ @@ -563,7 +563,7 @@ }, { "cell_type": "markdown", - "id": "3d878364", + "id": "3512b8e4", "metadata": {}, "source": [ "(case_2)=\n", @@ -575,13 +575,13 @@ "we will demonstrate using the standard straight-line distance and default cable burying rates.\n", "\n", "This case will rely on the\n", - "[`library/cables/example_custom_array_simple.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_simple.yaml) configuration." + "[`library/project/config/example_custom_array_simple.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/project/config/cables/example_custom_array_simple.yaml) configuration." ] }, { "cell_type": "code", "execution_count": 7, - "id": "c1ca2920", + "id": "83b5abed", "metadata": {}, "outputs": [ { @@ -605,7 +605,7 @@ }, { "cell_type": "markdown", - "id": "a29c491a", + "id": "e87ccff7", "metadata": {}, "source": [ "The below figure demonstrates the meaning of the straight-line distance between two points." @@ -614,7 +614,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "785f1989", + "id": "a56eacbc", "metadata": {}, "outputs": [ { @@ -644,7 +644,7 @@ }, { "cell_type": "markdown", - "id": "465c4c59", + "id": "bb1d967f", "metadata": {}, "source": [ "Here the cable length and bury speed are still set to 0 to indicate that they are unknown, which\n", @@ -655,7 +655,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "35c29773", + "id": "927b1b00", "metadata": {}, "outputs": [ { @@ -918,7 +918,7 @@ }, { "cell_type": "markdown", - "id": "b44d138a", + "id": "ccedaa00", "metadata": {}, "source": [ "For later comparison, we'll show the cabling costs for the straight-line cabling assumption." @@ -927,7 +927,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "13a3b94d", + "id": "9d5d57fe", "metadata": {}, "outputs": [ { @@ -952,7 +952,7 @@ }, { "cell_type": "markdown", - "id": "6a674d26", + "id": "243429eb", "metadata": {}, "source": [ "(case_3)=\n", @@ -977,7 +977,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "0209f5b5", + "id": "78e9bc76", "metadata": {}, "outputs": [ { @@ -1192,18 +1192,18 @@ }, { "cell_type": "markdown", - "id": "68f8ed8f", + "id": "02a62d7f", "metadata": {}, "source": [ "Using the distance-based location data requires us to set `distance` to True in the\n", "`array_system_design` section of the configuration. This change is shown below in the\n", - "[`library/cables/example_custom_array_simple_distance_based.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_simple_distance_based.yaml) configuration." + "[`library/project/config/example_custom_array_simple_distance_based.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_simple_distance_based.yaml) configuration." ] }, { "cell_type": "code", "execution_count": 12, - "id": "def4f2ab", + "id": "85a061dd", "metadata": {}, "outputs": [ { @@ -1228,7 +1228,7 @@ }, { "cell_type": "markdown", - "id": "f4fb4080", + "id": "6213bd07", "metadata": {}, "source": [ "Alternatively, we can set the `distance=True` when calling the `CustomArraySystemDesign`, however\n", @@ -1241,7 +1241,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "80963443", + "id": "c84365d4", "metadata": {}, "outputs": [ { @@ -1271,7 +1271,7 @@ }, { "cell_type": "markdown", - "id": "3443d9e5", + "id": "dc1f3e0b", "metadata": {}, "source": [ "Overall, the cabling cost is highly similar, with the difference being attributed to the method\n", @@ -1281,7 +1281,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "c44de973", + "id": "a969aefb", "metadata": {}, "outputs": [ { @@ -1306,7 +1306,7 @@ }, { "cell_type": "markdown", - "id": "b5f6feac", + "id": "82e12719", "metadata": {}, "source": [ "(case_4)=\n", @@ -1318,7 +1318,7 @@ "additional cable lengths.\n", "\n", "In the\n", - "[`library/cables/example_custom_array_exclusions.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_exclusions.yaml)\n", + "[`library/project/config/example_custom_array_exclusions.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_exclusions.yaml)\n", "configuration, a 4.8% exclusion is applied to the entire farm. When plotting farms with exclusion\n", "zones, they will not be shown since we are not mapping the true cable path, simply the connections\n", "between turbines. In this case, we can also a modest increase in cabling costs resulting from the\n", @@ -1328,7 +1328,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "59b5e904", + "id": "e6c2c75b", "metadata": {}, "outputs": [ { @@ -1365,7 +1365,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "024c8036", + "id": "1880d678", "metadata": {}, "outputs": [ { @@ -1390,7 +1390,7 @@ }, { "cell_type": "markdown", - "id": "b0d0a841", + "id": "529e7d83", "metadata": {}, "source": [ "(case_5)=\n", @@ -1414,7 +1414,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "3833eb5d", + "id": "b94374f2", "metadata": {}, "outputs": [ { @@ -1441,7 +1441,7 @@ }, { "cell_type": "markdown", - "id": "46b1fda0", + "id": "d7986431", "metadata": {}, "source": [ "Note that there are now cable lengths defined as well as burial speeds for the installation phase." @@ -1450,7 +1450,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "60c694ae", + "id": "32d5e0ec", "metadata": {}, "outputs": [ { @@ -1713,7 +1713,7 @@ }, { "cell_type": "markdown", - "id": "9656bad6", + "id": "24c19f35", "metadata": {}, "source": [ "Once again, the cabling costs have increased." @@ -1722,7 +1722,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "64fb59cd", + "id": "a7cd527c", "metadata": {}, "outputs": [ { @@ -1747,7 +1747,7 @@ }, { "cell_type": "markdown", - "id": "deed3cbb", + "id": "2e4caba0", "metadata": {}, "source": [ "(running)=\n", @@ -1758,7 +1758,7 @@ "### Setting Up The Cases\n", "\n", "Using the\n", - "[`library/cables/example_array_cable_install.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_array_cable_install.yaml)\n", + "[`library/project/config/example_array_cable_install.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_array_cable_install.yaml)\n", "configuration as a base configuration, we'll create a new configuration for each of the cases\n", "using each case's `design_result` as the `array_system` values." ] @@ -1766,7 +1766,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "cacd4552", + "id": "4d0f2cd2", "metadata": {}, "outputs": [], "source": [ @@ -1792,7 +1792,7 @@ }, { "cell_type": "markdown", - "id": "fc5029fe", + "id": "a3d7f72b", "metadata": {}, "source": [ "### Run And Inspect The Simulation Results\n", @@ -1805,7 +1805,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "d6996132", + "id": "2bb15aaf", "metadata": {}, "outputs": [ { @@ -1818,20 +1818,6 @@ "with exclusions | $24,784,480.17 | 2,391\n", "custom | $31,792,520.58 | 3,088\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "custom | $31,792,520.58 | 3,088" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] } ], "source": [ @@ -1848,7 +1834,7 @@ }, { "cell_type": "markdown", - "id": "5b768d6c", + "id": "584dc3c0", "metadata": {}, "source": [ "(project_manager)=\n", @@ -1856,14 +1842,14 @@ "\n", "We will now incorporate the desgin settings from [Case 5](#case_5) to demonstrate incorporation\n", "of the custom array design tooling into `ProjectManager`. This example will use the\n", - "[`library/cables/example_custom_array_project_manager.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/cables/example_custom_array_project_manager.yaml)\n", + "[`library/project/config/example_custom_array_project_manager.yaml`](https://github.com/NLRWindSystems/ORBIT/tree/main/library/project/config/example_custom_array_project_manager.yaml)\n", "configuration." ] }, { "cell_type": "code", "execution_count": 22, - "id": "a3a1658c", + "id": "2f024f0b", "metadata": {}, "outputs": [ { @@ -1925,7 +1911,7 @@ }, { "cell_type": "markdown", - "id": "0ebe43bc", + "id": "91b951d8", "metadata": {}, "source": [ "Below, we can see that the results coming from the `ProjectManager` are the same as the additive\n", @@ -1935,7 +1921,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "64b8a2c2", + "id": "a9d20134", "metadata": {}, "outputs": [ { diff --git a/examples/export_cable_system.ipynb b/examples/export_cable_system.ipynb index 893f33e1..4fbe090a 100644 --- a/examples/export_cable_system.ipynb +++ b/examples/export_cable_system.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "ef2ec428", + "id": "ff9785f8", "metadata": {}, "source": [ "# HVAC vs HVDC Systems\n", @@ -17,7 +17,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "1bdcfa15", + "id": "53e129be", "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "markdown", - "id": "27712633", + "id": "a46a1ebb", "metadata": {}, "source": [ "## Setup The Models\n", @@ -50,7 +50,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "25a42ce3", + "id": "c0429d91", "metadata": {}, "outputs": [], "source": [ @@ -79,7 +79,7 @@ }, { "cell_type": "markdown", - "id": "65677c91", + "id": "31f7a1d1", "metadata": {}, "source": [ "Now we can create an HVAC and HVDC variation of the `base_config`" @@ -88,7 +88,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "b69c62c6", + "id": "ed2ae832", "metadata": {}, "outputs": [ { @@ -120,7 +120,7 @@ }, { "cell_type": "markdown", - "id": "d3c8be73", + "id": "575e98dd", "metadata": {}, "source": [ "## Compare the Results" @@ -129,7 +129,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "9cbdb025", + "id": "53449b23", "metadata": {}, "outputs": [ { @@ -149,7 +149,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "4b30149b", + "id": "95b9ed28", "metadata": {}, "outputs": [ { @@ -263,7 +263,7 @@ }, { "cell_type": "markdown", - "id": "8274721a", + "id": "90282302", "metadata": {}, "source": [ "## Setup The Parametric Runs\n", @@ -277,7 +277,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "41ef8149", + "id": "ad9bf4b8", "metadata": {}, "outputs": [], "source": [ @@ -297,7 +297,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "f2842c29", + "id": "8b2350a7", "metadata": {}, "outputs": [], "source": [ @@ -309,7 +309,7 @@ }, { "cell_type": "markdown", - "id": "5eb93e3f", + "id": "92c751fa", "metadata": {}, "source": [ "## Compare the Cost vs Capacity Trade Off\n", @@ -322,7 +322,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "3d3ec2cf", + "id": "326b2813", "metadata": {}, "outputs": [ { diff --git a/examples/fixed_bottom_installations.ipynb b/examples/fixed_bottom_installations.ipynb index 9ec029b1..83253307 100644 --- a/examples/fixed_bottom_installations.ipynb +++ b/examples/fixed_bottom_installations.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "4a8b3042", + "id": "33de52a0", "metadata": {}, "source": [ "# Fixed-Bottom Substructure Installation Models in ORBIT\n", @@ -24,14 +24,14 @@ { "cell_type": "code", "execution_count": 1, - "id": "7426cfa6", + "id": "35988c9b", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /var/folders/q5/tfpytqxn0r396dfg7rk5sj8rwq9tvv/T/ipykernel_41437/4204870401.py:19\n", + "UserWarning: /var/folders/q5/tfpytqxn0r396dfg7rk5sj8rwq9tvv/T/ipykernel_67380/4204870401.py:19\n", "Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n" ] } @@ -62,7 +62,7 @@ }, { "cell_type": "markdown", - "id": "86377ae3", + "id": "76784f7a", "metadata": {}, "source": [ "## Load The Configurations\n", @@ -75,7 +75,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "ccd8e5e5", + "id": "28ff5701", "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "markdown", - "id": "93501b73", + "id": "23230cad", "metadata": {}, "source": [ "The primary differences between these projects deal with the installation strategies, and\n", @@ -106,7 +106,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "b7b464e5", + "id": "76fb2d09", "metadata": {}, "outputs": [ { @@ -135,7 +135,7 @@ }, { "cell_type": "markdown", - "id": "a1f1c79f", + "id": "4dfefbda", "metadata": {}, "source": [ "## Run The Three Cases\n", @@ -146,7 +146,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "c71efe98", + "id": "b9e836af", "metadata": {}, "outputs": [ { @@ -178,7 +178,7 @@ }, { "cell_type": "markdown", - "id": "bf7ef3e8", + "id": "20d27b0e", "metadata": {}, "source": [ "## Results Comparison\n", @@ -189,7 +189,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "2aaaec09", + "id": "e356bb5b", "metadata": {}, "outputs": [ { @@ -405,7 +405,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "34caffe4", + "id": "2b701461", "metadata": {}, "outputs": [], "source": [ @@ -507,7 +507,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "02f55af5", + "id": "0eff096f", "metadata": {}, "outputs": [ { @@ -527,7 +527,7 @@ }, { "cell_type": "markdown", - "id": "9975f507", + "id": "4646cecf", "metadata": {}, "source": [ "### Substructure and Turbine Installation CapEx Breakdown" @@ -536,7 +536,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "36441f1b", + "id": "d4d076ef", "metadata": {}, "outputs": [ { @@ -621,7 +621,7 @@ }, { "cell_type": "markdown", - "id": "c1aa5a26", + "id": "5235830d", "metadata": {}, "source": [ "### Comparing Installation Timing\n", @@ -636,7 +636,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "454a1a05", + "id": "257332e0", "metadata": {}, "outputs": [ { diff --git a/examples/introduction.ipynb b/examples/introduction.ipynb index 046da2aa..4a6434b0 100644 --- a/examples/introduction.ipynb +++ b/examples/introduction.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "df44d4ab", + "id": "47248323", "metadata": {}, "source": [ "(intro-tutorial)=\n", @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "19082169", + "id": "b7e94537", "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "markdown", - "id": "e3b4d3bf", + "id": "18f69943", "metadata": {}, "source": [ "While this introduction will focus on the monopile design and installation to highlight working with\n", @@ -48,7 +48,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "65b015d7", + "id": "83352053", "metadata": {}, "outputs": [ { @@ -76,7 +76,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "6a818483", + "id": "e13fd026", "metadata": {}, "outputs": [ { @@ -103,7 +103,7 @@ }, { "cell_type": "markdown", - "id": "232ad20c", + "id": "626210a1", "metadata": {}, "source": [ "## Configuration Basics\n", @@ -120,7 +120,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "31de88c1", + "id": "485df507", "metadata": {}, "outputs": [ { @@ -158,7 +158,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "4b139d6a", + "id": "6ca72058", "metadata": {}, "outputs": [ { @@ -196,7 +196,7 @@ }, { "cell_type": "markdown", - "id": "04a0f4cd", + "id": "1c528589", "metadata": {}, "source": [ "### Design Models\n", @@ -212,7 +212,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "91279471", + "id": "5e02645b", "metadata": {}, "outputs": [], "source": [ @@ -235,7 +235,7 @@ }, { "cell_type": "markdown", - "id": "a0ce740f", + "id": "d4aff33d", "metadata": {}, "source": [ "Similar to `expected_config`, every design and installation model contains a `run` method that runs\n", @@ -245,7 +245,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "24a67f3e", + "id": "6dc52787", "metadata": {}, "outputs": [ { @@ -280,7 +280,7 @@ }, { "cell_type": "markdown", - "id": "8e6fa89f", + "id": "39dd470b", "metadata": {}, "source": [ "### Incomplete or Incorrect Configurations\n", @@ -296,7 +296,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "6dc31de4", + "id": "e18e28f7", "metadata": { "tags": [ "raises-exception" @@ -326,7 +326,7 @@ }, { "cell_type": "markdown", - "id": "1fb32df5", + "id": "7397b81c", "metadata": {}, "source": [ "### Optional Inputs\n", @@ -340,7 +340,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "b1a77dd3", + "id": "35fcb909", "metadata": {}, "outputs": [ { @@ -395,7 +395,7 @@ }, { "cell_type": "markdown", - "id": "32ed5f7d", + "id": "99f0c1af", "metadata": {}, "source": [ "### Overriding Values from the Design Phase\n", @@ -409,7 +409,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "d3e137b8", + "id": "c0b03c42", "metadata": {}, "outputs": [ { @@ -462,7 +462,7 @@ }, { "cell_type": "markdown", - "id": "c72b6d4c", + "id": "e6d100fb", "metadata": {}, "source": [ "### Installation Phases\n", @@ -482,7 +482,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "648a6896", + "id": "f1d51478", "metadata": {}, "outputs": [ { @@ -598,7 +598,7 @@ }, { "cell_type": "markdown", - "id": "d93a518e", + "id": "d4b0d71a", "metadata": {}, "source": [ "### Loading and Saving Configurations\n", @@ -717,7 +717,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "401b77a1", + "id": "0c94368a", "metadata": {}, "outputs": [ { @@ -822,7 +822,7 @@ }, { "cell_type": "markdown", - "id": "252e6be3", + "id": "c58b0ec5", "metadata": {}, "source": [ "Now, we can combine the monopile design and installation configurations that were\n", @@ -833,7 +833,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "012e311d", + "id": "e73355fa", "metadata": {}, "outputs": [ { @@ -841,6 +841,20 @@ "output_type": "stream", "text": [ " Project Capex: 303.23 M\n", + "\n", + " Substructure: 269.26 M\n", + " Substructure Installation: 33.97 M\n", + " Onshore Substation: 0.00 M\n", + " Turbine: 780.00 M\n", + " Soft: 274.09 M\n", + " Project: 355.00 M\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", " Substructure: 269.26 M\n", " Substructure Installation: 33.97 M\n", " Onshore Substation: 0.00 M\n", @@ -869,7 +883,7 @@ }, { "cell_type": "markdown", - "id": "6e883464", + "id": "74ff8aa2", "metadata": {}, "source": [ "To continue with the previous subsection's demonstration, we can also save the final configuration\n", @@ -879,7 +893,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "00736074", + "id": "2c4409af", "metadata": {}, "outputs": [ { diff --git a/examples/parametric_manager.ipynb b/examples/parametric_manager.ipynb index d6e4ebac..49395a54 100644 --- a/examples/parametric_manager.ipynb +++ b/examples/parametric_manager.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "845ac037", + "id": "d2bdde4c", "metadata": {}, "source": [ "(parametric-manager-tutorial)=\n", @@ -20,7 +20,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "8b3470ca", + "id": "4b4c65ff", "metadata": {}, "outputs": [], "source": [ @@ -43,9 +43,11 @@ }, { "cell_type": "markdown", - "id": "0ff67c59", + "id": "5a5ff43e", "metadata": {}, "source": [ + "## Setting Up The Parameterized Inputs\n", + "\n", "For all the non-parameterized inputs, they can be left as-is. However, all parameterized variables\n", "should be provided in a separate dictionary as a list. Because ORBIT uses the `benedict` library\n", "for more streamlined dictionary access, nested keys can be represented using dot-notation as is\n", @@ -55,20 +57,19 @@ { "cell_type": "code", "execution_count": 2, - "id": "37ce5ece", + "id": "eb51bc30", "metadata": {}, "outputs": [], "source": [ "params = {\n", " \"site.depth\": list(range(10, 71, 10)),\n", " \"site.distance\": list(range(20, 201, 20)),\n", - " \"site.distance_to_landfall\": [60, 80, 100],\n", "}" ] }, { "cell_type": "markdown", - "id": "5105feaa", + "id": "0d865a4a", "metadata": {}, "source": [ "Similar to the parameterized inputs, we must also define the desired outputs. However, outputs must\n", @@ -79,7 +80,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "1f99b07b", + "id": "b5463cdf", "metadata": {}, "outputs": [], "source": [ @@ -91,9 +92,11 @@ }, { "cell_type": "markdown", - "id": "c59937cc", + "id": "d9817b23", "metadata": {}, "source": [ + "## Previewing and Running The Model\n", + "\n", "If many parameters are configured, it will take a longer time to run, especially if a weather\n", "profile is provided and `product=True`. To get an idea of the total run time, use the `preview`\n", "method, as seen below.\n", @@ -108,7 +111,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "e7d711de", + "id": "b6d16cc9", "metadata": {}, "outputs": [ { @@ -116,16 +119,16 @@ "output_type": "stream", "text": [ "ORBIT library intialized at '/Users/rhammond/GitHub_Public/ORBIT/library'\n", - "10 runs elapsed time: 3.75s\n", - "210 runs estimated time: 78.67s\n" + "10 runs elapsed time: 3.64s\n", + "70 runs estimated time: 25.45s\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "10 runs elapsed time: 3.75s\n", - "210 runs estimated time: 78.67s\n" + "10 runs elapsed time: 3.64s\n", + "70 runs estimated time: 25.45s\n" ] }, { @@ -151,7 +154,6 @@ " \n", " site.depth\n", " site.distance\n", - " site.distance_to_landfall\n", " Installation\n", " System\n", " \n", @@ -159,112 +161,90 @@ " \n", " \n", " 0\n", - " 20\n", - " 40\n", - " 100\n", - " 3.445039e+08\n", - " 1.301853e+09\n", + " 60\n", + " 160\n", + " 3.605703e+08\n", + " 1.294177e+09\n", " \n", " \n", " 1\n", - " 20\n", - " 100\n", - " 80\n", - " 3.525076e+08\n", - " 1.227865e+09\n", + " 40\n", + " 40\n", + " 3.131938e+08\n", + " 1.173294e+09\n", " \n", " \n", " 2\n", + " 50\n", " 20\n", - " 160\n", - " 100\n", - " 3.751548e+08\n", - " 1.301853e+09\n", + " 3.072970e+08\n", + " 1.232635e+09\n", " \n", " \n", " 3\n", - " 60\n", - " 180\n", - " 60\n", - " 3.800057e+08\n", - " 1.386662e+09\n", + " 30\n", + " 40\n", + " 3.126626e+08\n", + " 1.116196e+09\n", " \n", " \n", " 4\n", - " 60\n", - " 60\n", - " 60\n", - " 3.386306e+08\n", - " 1.386662e+09\n", + " 10\n", + " 20\n", + " 3.044819e+08\n", + " 1.008934e+09\n", " \n", " \n", " 5\n", " 40\n", - " 40\n", - " 60\n", - " 3.264900e+08\n", - " 1.265779e+09\n", + " 20\n", + " 3.055845e+08\n", + " 1.173294e+09\n", " \n", " \n", " 6\n", - " 10\n", - " 60\n", - " 80\n", - " 3.401561e+08\n", - " 1.175408e+09\n", + " 70\n", + " 20\n", + " 3.097431e+08\n", + " 1.357158e+09\n", " \n", " \n", " 7\n", - " 20\n", - " 160\n", - " 80\n", - " 3.655228e+08\n", - " 1.227865e+09\n", + " 40\n", + " 180\n", + " 3.523339e+08\n", + " 1.173294e+09\n", " \n", " \n", " 8\n", " 70\n", - " 140\n", - " 80\n", - " 3.764944e+08\n", - " 1.523631e+09\n", + " 60\n", + " 3.268419e+08\n", + " 1.357158e+09\n", " \n", " \n", " 9\n", - " 70\n", + " 60\n", " 100\n", - " 80\n", - " 3.644137e+08\n", - " 1.523631e+09\n", + " 3.417226e+08\n", + " 1.294177e+09\n", " \n", " \n", "\n", "" ], "text/plain": [ - " site.depth site.distance site.distance_to_landfall Installation \\\n", - "0 20 40 100 3.445039e+08 \n", - "1 20 100 80 3.525076e+08 \n", - "2 20 160 100 3.751548e+08 \n", - "3 60 180 60 3.800057e+08 \n", - "4 60 60 60 3.386306e+08 \n", - "5 40 40 60 3.264900e+08 \n", - "6 10 60 80 3.401561e+08 \n", - "7 20 160 80 3.655228e+08 \n", - "8 70 140 80 3.764944e+08 \n", - "9 70 100 80 3.644137e+08 \n", - "\n", - " System \n", - "0 1.301853e+09 \n", - "1 1.227865e+09 \n", - "2 1.301853e+09 \n", - "3 1.386662e+09 \n", - "4 1.386662e+09 \n", - "5 1.265779e+09 \n", - "6 1.175408e+09 \n", - "7 1.227865e+09 \n", - "8 1.523631e+09 \n", - "9 1.523631e+09 " + " site.depth site.distance Installation System\n", + "0 60 160 3.605703e+08 1.294177e+09\n", + "1 40 40 3.131938e+08 1.173294e+09\n", + "2 50 20 3.072970e+08 1.232635e+09\n", + "3 30 40 3.126626e+08 1.116196e+09\n", + "4 10 20 3.044819e+08 1.008934e+09\n", + "5 40 20 3.055845e+08 1.173294e+09\n", + "6 70 20 3.097431e+08 1.357158e+09\n", + "7 40 180 3.523339e+08 1.173294e+09\n", + "8 70 60 3.268419e+08 1.357158e+09\n", + "9 60 100 3.417226e+08 1.294177e+09" ] }, "execution_count": 4, @@ -280,7 +260,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "6347de2c", + "id": "e944adcd", "metadata": {}, "outputs": [], "source": [ @@ -289,14 +269,14 @@ }, { "cell_type": "markdown", - "id": "0c579798", + "id": "660fc0eb", "metadata": {}, "source": [ "The results are saved as a pandas DataFrame in the `results` attribute where each row represents a\n", "different scenario run and the columns are labeled with with the various parameters and results\n", "values that were configured.\n", "\n", - "## Plotting\n", + "## Plotting The Results\n", "\n", "It is more convenient to plot the results of the `ParametricManager` than it is to view them as a\n", "table, especially with a large number of parameters. First, we will create a matrix of results\n", @@ -307,26 +287,9 @@ { "cell_type": "code", "execution_count": 6, - "id": "c4cf4f54", + "id": "18470062", "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Index contains duplicate entries, cannot reshape", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m results = project.results.set_index([\u001b[33m\"\u001b[39m\u001b[33msite.depth\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33msite.distance\u001b[39m\u001b[33m\"\u001b[39m]) / \u001b[32m1e6\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m installation_arr = \u001b[43mresults\u001b[49m\u001b[43m.\u001b[49m\u001b[43munstack\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m[\u001b[33m\"\u001b[39m\u001b[33mInstallation\u001b[39m\u001b[33m\"\u001b[39m].sort_index(ascending=\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[32m 3\u001b[39m system_arr = results.unstack()[\u001b[33m\"\u001b[39m\u001b[33mSystem\u001b[39m\u001b[33m\"\u001b[39m].sort_index()\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/site-packages/pandas/core/frame.py:9928\u001b[39m, in \u001b[36mDataFrame.unstack\u001b[39m\u001b[34m(self, level, fill_value, sort)\u001b[39m\n\u001b[32m 9864\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 9865\u001b[39m \u001b[33;03mPivot a level of the (necessarily hierarchical) index labels.\u001b[39;00m\n\u001b[32m 9866\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 9924\u001b[39m \u001b[33;03mdtype: float64\u001b[39;00m\n\u001b[32m 9925\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 9926\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpandas\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcore\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mreshape\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mreshape\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m unstack\n\u001b[32m-> \u001b[39m\u001b[32m9928\u001b[39m result = \u001b[43munstack\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfill_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 9930\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result.__finalize__(\u001b[38;5;28mself\u001b[39m, method=\u001b[33m\"\u001b[39m\u001b[33munstack\u001b[39m\u001b[33m\"\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/site-packages/pandas/core/reshape/reshape.py:504\u001b[39m, in \u001b[36munstack\u001b[39m\u001b[34m(obj, level, fill_value, sort)\u001b[39m\n\u001b[32m 502\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(obj, DataFrame):\n\u001b[32m 503\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(obj.index, MultiIndex):\n\u001b[32m--> \u001b[39m\u001b[32m504\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_unstack_frame\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfill_value\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfill_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 505\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 506\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m obj.T.stack(future_stack=\u001b[38;5;28;01mTrue\u001b[39;00m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/site-packages/pandas/core/reshape/reshape.py:529\u001b[39m, in \u001b[36m_unstack_frame\u001b[39m\u001b[34m(obj, level, fill_value, sort)\u001b[39m\n\u001b[32m 525\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_unstack_frame\u001b[39m(\n\u001b[32m 526\u001b[39m obj: DataFrame, level, fill_value=\u001b[38;5;28;01mNone\u001b[39;00m, sort: \u001b[38;5;28mbool\u001b[39m = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m 527\u001b[39m ) -> DataFrame:\n\u001b[32m 528\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(obj.index, MultiIndex) \u001b[38;5;66;03m# checked by caller\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m529\u001b[39m unstacker = \u001b[43m_Unstacker\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 530\u001b[39m \u001b[43m \u001b[49m\u001b[43mobj\u001b[49m\u001b[43m.\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m=\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconstructor\u001b[49m\u001b[43m=\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_constructor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msort\u001b[49m\u001b[43m=\u001b[49m\u001b[43msort\u001b[49m\n\u001b[32m 531\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 533\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m obj._can_fast_transpose:\n\u001b[32m 534\u001b[39m mgr = obj._mgr.unstack(unstacker, fill_value=fill_value)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/site-packages/pandas/core/reshape/reshape.py:154\u001b[39m, in \u001b[36m_Unstacker.__init__\u001b[39m\u001b[34m(self, index, level, constructor, sort)\u001b[39m\n\u001b[32m 146\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m num_cells > np.iinfo(np.int32).max:\n\u001b[32m 147\u001b[39m warnings.warn(\n\u001b[32m 148\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mThe following operation may generate \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnum_cells\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m cells \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 149\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33min the resulting pandas object.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 150\u001b[39m PerformanceWarning,\n\u001b[32m 151\u001b[39m stacklevel=find_stack_level(),\n\u001b[32m 152\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m154\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_make_selectors\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/site-packages/pandas/core/reshape/reshape.py:210\u001b[39m, in \u001b[36m_Unstacker._make_selectors\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 207\u001b[39m mask.put(selector, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 209\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m mask.sum() < \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m.index):\n\u001b[32m--> \u001b[39m\u001b[32m210\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mIndex contains duplicate entries, cannot reshape\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 212\u001b[39m \u001b[38;5;28mself\u001b[39m.group_index = comp_index\n\u001b[32m 213\u001b[39m \u001b[38;5;28mself\u001b[39m.mask = mask\n", - "\u001b[31mValueError\u001b[39m: Index contains duplicate entries, cannot reshape" - ] - } - ], + "outputs": [], "source": [ "results = project.results.set_index([\"site.depth\", \"site.distance\"]) / 1e6\n", "installation_arr = results.unstack()[\"Installation\"].sort_index(ascending=False)\n", @@ -335,7 +298,7 @@ }, { "cell_type": "markdown", - "id": "43292a47", + "id": "6650e803", "metadata": {}, "source": [ "As mentioned in the [`ProjectManager` tutorial](#project-manager-tutorial), the system CapEx will\n", @@ -346,25 +309,14 @@ { "cell_type": "code", "execution_count": 7, - "id": "0d2dbb88", + "id": "d9a7e581", "metadata": {}, "outputs": [ - { - "ename": "NameError", - "evalue": "name 'installation_arr' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m 1\u001b[39m fig = plt.figure()\n\u001b[32m 2\u001b[39m ax = fig.add_subplot(\u001b[32m111\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m im = ax.imshow(\u001b[43minstallation_arr\u001b[49m.values, vmin=\u001b[32m290\u001b[39m, vmax=\u001b[32m380\u001b[39m)\n\u001b[32m 6\u001b[39m cbar = fig.colorbar(im, ax=ax, shrink=\u001b[32m0.8\u001b[39m)\n\u001b[32m 7\u001b[39m cbar.ax.set_ylabel(\u001b[33m\"\u001b[39m\u001b[33mInstallation CapEx (millions, USD)\u001b[39m\u001b[33m\"\u001b[39m, rotation=-\u001b[32m90\u001b[39m, va=\u001b[33m\"\u001b[39m\u001b[33mbottom\u001b[39m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mNameError\u001b[39m: name 'installation_arr' is not defined" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -391,7 +343,7 @@ }, { "cell_type": "markdown", - "id": "74a3ba85", + "id": "07041662", "metadata": {}, "source": [ "However, the system CapEx only increases as the site's depth increases because only the site's\n", @@ -402,23 +354,12 @@ { "cell_type": "code", "execution_count": 8, - "id": "2cede1a9", + "id": "a6586284", "metadata": {}, "outputs": [ - { - "ename": "NameError", - "evalue": "name 'system_arr' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m 1\u001b[39m fig = plt.figure()\n\u001b[32m 2\u001b[39m ax = fig.add_subplot(\u001b[32m111\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m x = \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(\u001b[43msystem_arr\u001b[49m.index))\n\u001b[32m 5\u001b[39m ax.bar(x, system_arr.values[:, \u001b[32m0\u001b[39m])\n\u001b[32m 7\u001b[39m ax.set_xticks(x)\n", - "\u001b[31mNameError\u001b[39m: name 'system_arr' is not defined" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -474,18 +415,18 @@ 12, 25, 41, - 48, - 54, - 60, - 65, - 77, - 82, - 84, - 97, - 101, - 107, - 123, - 129 + 50, + 55, + 61, + 66, + 80, + 85, + 87, + 100, + 104, + 110, + 126, + 132 ] }, "nbformat": 4, diff --git a/examples/project_manager.ipynb b/examples/project_manager.ipynb index 209b6029..93df8844 100644 --- a/examples/project_manager.ipynb +++ b/examples/project_manager.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "af58b3c4", + "id": "19b523a9", "metadata": {}, "source": [ "(project-manager-tutorial)=\n", @@ -16,7 +16,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "f29724f8", + "id": "3c12c93e", "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "markdown", - "id": "4220d5f1", + "id": "31ebc886", "metadata": {}, "source": [ "## Compiling Input Requirements Dynamically\n", @@ -49,7 +49,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "f7dd9d68", + "id": "ac77ac24", "metadata": {}, "outputs": [ { @@ -165,7 +165,7 @@ }, { "cell_type": "markdown", - "id": "c73f5fe4", + "id": "7a1f99b2", "metadata": {}, "source": [ "Using the results of the `expected_config`, the following configuration is now created to minimally\n", @@ -177,7 +177,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "af43c2e8", + "id": "b69c5291", "metadata": {}, "outputs": [ { @@ -233,7 +233,7 @@ }, { "cell_type": "markdown", - "id": "29df9d90", + "id": "64b60d96", "metadata": {}, "source": [ "## Weather Profiles\n", @@ -246,7 +246,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "78c8b350", + "id": "ffa08e9d", "metadata": {}, "outputs": [], "source": [ @@ -258,7 +258,7 @@ }, { "cell_type": "markdown", - "id": "be30c6b0", + "id": "868dc502", "metadata": {}, "source": [ "## Accessing Individual Models\n", @@ -271,7 +271,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "b2be3cea", + "id": "3e0ab3e2", "metadata": {}, "outputs": [ { @@ -289,7 +289,7 @@ }, { "cell_type": "markdown", - "id": "3e0c92ef", + "id": "e94ffffb", "metadata": {}, "source": [ "## Phase-Specific Configurations\n", @@ -379,7 +379,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "8ef99dca", + "id": "4f1374a3", "metadata": {}, "outputs": [], "source": [ @@ -441,7 +441,7 @@ }, { "cell_type": "markdown", - "id": "be12cc7c", + "id": "091f502a", "metadata": {}, "source": [ "Now, we can make a quick visualization to see how the start timing plays out. Notice how the\n", @@ -453,7 +453,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "b1cafa79", + "id": "68fbf09d", "metadata": {}, "outputs": [ { @@ -486,7 +486,7 @@ }, { "cell_type": "markdown", - "id": "032effe3", + "id": "b6222780", "metadata": {}, "source": [ "(phase-dependent-timing)=\n", @@ -501,7 +501,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "a3377bb5", + "id": "44e86333", "metadata": {}, "outputs": [ { diff --git a/examples/supply_chains.ipynb b/examples/supply_chains.ipynb index 8cea7d9a..b3fd7112 100644 --- a/examples/supply_chains.ipynb +++ b/examples/supply_chains.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "6960a153", + "id": "d144d625", "metadata": {}, "source": [ "# Modeling Supply Chains\n", @@ -18,14 +18,14 @@ { "cell_type": "code", "execution_count": 1, - "id": "f9d4941c", + "id": "657915e5", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /var/folders/q5/tfpytqxn0r396dfg7rk5sj8rwq9tvv/T/ipykernel_41557/774869178.py:14\n", + "UserWarning: /var/folders/q5/tfpytqxn0r396dfg7rk5sj8rwq9tvv/T/ipykernel_67464/774869178.py:14\n", "Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n" ] } @@ -51,7 +51,7 @@ }, { "cell_type": "markdown", - "id": "53a6ee92", + "id": "d2f61866", "metadata": {}, "source": [ "## Preparing The Cases\n", @@ -66,25 +66,19 @@ { "cell_type": "code", "execution_count": 2, - "id": "b5ef1a8d", + "id": "25b06f8e", "metadata": {}, "outputs": [ { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'configs/example_fixed_project.yaml'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m base_jacket_config = \u001b[43mload_config\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mconfigs/example_fixed_project.yaml\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 2\u001b[39m base_jacket_config[\u001b[33m\"\u001b[39m\u001b[33mjacket\u001b[39m\u001b[33m\"\u001b[39m] = {\n\u001b[32m 3\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mdiameter\u001b[39m\u001b[33m\"\u001b[39m: \u001b[32m10\u001b[39m,\n\u001b[32m 4\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mheight\u001b[39m\u001b[33m\"\u001b[39m: \u001b[32m100\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 8\u001b[39m \u001b[33m\"\u001b[39m\u001b[33munit_cost\u001b[39m\u001b[33m\"\u001b[39m: \u001b[32m1e6\u001b[39m\n\u001b[32m 9\u001b[39m }\n\u001b[32m 11\u001b[39m slow_prod_config = deepcopy(base_jacket_config)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/GitHub_Public/ORBIT/ORBIT/config.py:29\u001b[39m, in \u001b[36mload_config\u001b[39m\u001b[34m(filepath)\u001b[39m\n\u001b[32m 19\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mload_config\u001b[39m(filepath):\n\u001b[32m 20\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 21\u001b[39m \u001b[33;03m Load an ORBIT config at `filepath`.\u001b[39;00m\n\u001b[32m 22\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 26\u001b[39m \u001b[33;03m Path to yaml config file.\u001b[39;00m\n\u001b[32m 27\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mPath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[32m 30\u001b[39m data = yaml.load(f, Loader=loader)\n\u001b[32m 32\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m data\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/orbit/lib/python3.11/pathlib.py:1044\u001b[39m, in \u001b[36mPath.open\u001b[39m\u001b[34m(self, mode, buffering, encoding, errors, newline)\u001b[39m\n\u001b[32m 1042\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m\"\u001b[39m\u001b[33mb\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[32m 1043\u001b[39m encoding = io.text_encoding(encoding)\n\u001b[32m-> \u001b[39m\u001b[32m1044\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m io.open(\u001b[38;5;28mself\u001b[39m, mode, buffering, encoding, errors, newline)\n", - "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: 'configs/example_fixed_project.yaml'" + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/rhammond/GitHub_Public/ORBIT/library'\n" ] } ], "source": [ - "base_jacket_config = load_config(\"configs/example_fixed_project.yaml\")\n", + "base_jacket_config = load_config(example_path / \"configs/example_fixed_project.yaml\")\n", "base_jacket_config[\"jacket\"] = {\n", " \"diameter\": 10,\n", " \"height\": 100,\n", @@ -119,7 +113,7 @@ }, { "cell_type": "markdown", - "id": "55a83b0a", + "id": "fb36cc57", "metadata": {}, "source": [ "## Comparing Results\n", @@ -130,18 +124,16 @@ { "cell_type": "code", "execution_count": 3, - "id": "deb4354f", + "id": "f5ed4b74", "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'case1_project' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCase 1 Installation Time: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mcase1_project\u001b[49m.total_phase_time\u001b[38;5;250m \u001b[39m/\u001b[38;5;250m \u001b[39m\u001b[32m24\u001b[39m\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m days\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 2\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCase 2 Installation Time: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcase2_project.total_phase_time\u001b[38;5;250m \u001b[39m/\u001b[38;5;250m \u001b[39m\u001b[32m24\u001b[39m\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m days\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 3\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mCase 3 Installation Time: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcase3_project.total_phase_time\u001b[38;5;250m \u001b[39m/\u001b[38;5;250m \u001b[39m\u001b[32m24\u001b[39m\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.1f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m days\u001b[39m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mNameError\u001b[39m: name 'case1_project' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "Case 1 Installation Time: 319.8 days\n", + "Case 2 Installation Time: 540.9 days\n", + "Case 3 Installation Time: 327.1 days\n" ] } ], @@ -153,7 +145,7 @@ }, { "cell_type": "markdown", - "id": "294d4123", + "id": "7a2428e3", "metadata": {}, "source": [ "### Installation Timing\n", @@ -166,21 +158,9 @@ { "cell_type": "code", "execution_count": 4, - "id": "46264357", + "id": "7e66b10c", "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'case2_project' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m case2_df = pd.DataFrame(\u001b[43mcase2_project\u001b[49m.env.actions)\n\u001b[32m 2\u001b[39m case2_deliveries = case2_df.loc[case2_df[\u001b[33m\"\u001b[39m\u001b[33maction\u001b[39m\u001b[33m\"\u001b[39m].str.contains(\u001b[33m\"\u001b[39m\u001b[33mDelivered\u001b[39m\u001b[33m\"\u001b[39m), [\u001b[33m\"\u001b[39m\u001b[33maction\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mtime\u001b[39m\u001b[33m\"\u001b[39m]]\n\u001b[32m 3\u001b[39m case2_deliveries[\u001b[33m\"\u001b[39m\u001b[33mnumber\u001b[39m\u001b[33m\"\u001b[39m] = case2_deliveries[\u001b[33m\"\u001b[39m\u001b[33maction\u001b[39m\u001b[33m\"\u001b[39m].str.split(\u001b[33m\"\u001b[39m\u001b[33m \u001b[39m\u001b[33m\"\u001b[39m).str[\u001b[32m1\u001b[39m].astype(\u001b[38;5;28mint\u001b[39m)\n", - "\u001b[31mNameError\u001b[39m: name 'case2_project' is not defined" - ] - } - ], + "outputs": [], "source": [ "case2_df = pd.DataFrame(case2_project.env.actions)\n", "case2_deliveries = case2_df.loc[case2_df[\"action\"].str.contains(\"Delivered\"), [\"action\", \"time\"]]\n", @@ -207,23 +187,12 @@ { "cell_type": "code", "execution_count": 5, - "id": "adef5c81", + "id": "d40aa77d", "metadata": {}, "outputs": [ - { - "ename": "NameError", - "evalue": "name 'case2_deliveries' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 1\u001b[39m fig = plt.figure(figsize=(\u001b[32m8\u001b[39m,\u001b[32m4\u001b[39m), dpi=\u001b[32m200\u001b[39m)\n\u001b[32m 2\u001b[39m ax = fig.add_subplot(\u001b[32m111\u001b[39m)\n\u001b[32m 4\u001b[39m ax.scatter(\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[43mcase2_deliveries\u001b[49m[\u001b[33m\"\u001b[39m\u001b[33mtime\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 6\u001b[39m case2_deliveries[\u001b[33m\"\u001b[39m\u001b[33mnumber\u001b[39m\u001b[33m\"\u001b[39m].cumsum(),\n\u001b[32m 7\u001b[39m marker=\u001b[33m\"\u001b[39m\u001b[33mo\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 8\u001b[39m c=\u001b[33m\"\u001b[39m\u001b[33mtab:blue\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 9\u001b[39m label=\u001b[33m\"\u001b[39m\u001b[33mSubstructure Delivered - Slow Fabrication\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 10\u001b[39m )\n\u001b[32m 11\u001b[39m ax.scatter(\n\u001b[32m 12\u001b[39m case2_installs[\u001b[33m\"\u001b[39m\u001b[33mtime\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 13\u001b[39m case2_installs[\u001b[33m\"\u001b[39m\u001b[33mnumber\u001b[39m\u001b[33m\"\u001b[39m].cumsum(),\n\u001b[32m (...)\u001b[39m\u001b[32m 16\u001b[39m label=\u001b[33m\"\u001b[39m\u001b[33mCompleted Installation - Slow Fabrication\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 17\u001b[39m )\n\u001b[32m 19\u001b[39m ax.scatter(\n\u001b[32m 20\u001b[39m case3_deliveries[\u001b[33m\"\u001b[39m\u001b[33mtime\u001b[39m\u001b[33m\"\u001b[39m],\n\u001b[32m 21\u001b[39m case3_deliveries[\u001b[33m\"\u001b[39m\u001b[33mnumber\u001b[39m\u001b[33m\"\u001b[39m].cumsum(),\n\u001b[32m (...)\u001b[39m\u001b[32m 24\u001b[39m label=\u001b[33m\"\u001b[39m\u001b[33mSubstructure Delivered - Increased Fabrication\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 25\u001b[39m )\n", - "\u001b[31mNameError\u001b[39m: name 'case2_deliveries' is not defined" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -279,7 +248,7 @@ }, { "cell_type": "markdown", - "id": "d4c63f6e", + "id": "eb1f4e84", "metadata": {}, "source": [ "### Port Storage" @@ -288,16 +257,28 @@ { "cell_type": "code", "execution_count": 6, - "id": "ec7f2b39", + "id": "1248270c", "metadata": {}, "outputs": [ { - "ename": "SyntaxError", - "evalue": "unterminated string literal (detected at line 28) (3778338468.py, line 28)", - "output_type": "error", - "traceback": [ - " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 28\u001b[39m\n\u001b[31m \u001b[39m\u001b[31max.axhline(4, ls=\"--\", lw=0.5, c='k', label=\"Theoretical Port Storage Limit)\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m unterminated string literal (detected at line 28)\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -306,29 +287,29 @@ "\n", "case2_installs_neg = case2_installs.copy()\n", "case2_installs_neg[\"number\"] *= -1\n", - "case2_total = pd.concat([case2_deliveries, case2_installs_neg]).sort_values('time')\n", - "case2_total['storage'] = case2_total['number'].cumsum()\n", + "case2_total = pd.concat([case2_deliveries, case2_installs_neg]).sort_values(\"time\")\n", + "case2_total[\"storage\"] = case2_total[\"number\"].cumsum()\n", "\n", "case3_installs_neg = case3_installs.copy()\n", "case3_installs_neg[\"number\"] *= -1\n", - "case3_total = pd.concat([case3_deliveries, case3_installs_neg]).sort_values('time')\n", - "case3_total['storage'] = case3_total['number'].cumsum()\n", + "case3_total = pd.concat([case3_deliveries, case3_installs_neg]).sort_values(\"time\")\n", + "case3_total[\"storage\"] = case3_total[\"number\"].cumsum()\n", "\n", "ax.plot(\n", - " case2_total['time'],\n", - " case2_total['storage'],\n", + " case2_total[\"time\"],\n", + " case2_total[\"storage\"],\n", " label=\"Storage Required - Slow Fabrication\"\n", ")\n", "ax.plot(\n", - " case3_total['time'],\n", - " case3_total['storage'],\n", + " case3_total[\"time\"],\n", + " case3_total[\"storage\"],\n", " label=\"Storage Required - Increased Fabrication\"\n", ")\n", "\n", "ax.set_xlim(0, ax.get_xlim()[1])\n", "# ax.set_ylim(0, 5)\n", "\n", - "ax.axhline(4, ls=\"--\", lw=0.5, c='k', label=\"Theoretical Port Storage Limit)\n", + "ax.axhline(4, ls=\"--\", lw=0.5, c=\"k\", label=\"Theoretical Port Storage Limit\")\n", "\n", "ax.set_xlabel(\"Simulation Time (h)\")\n", "ax.set_ylabel(\"Substructures\")\n", diff --git a/pyproject.toml b/pyproject.toml index 0fc05777..8901e5eb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -23,6 +23,7 @@ dependencies = [ "pyyaml", "python-benedict", "statsmodels", + "matplotlib", ] keywords = [ "python3", @@ -66,7 +67,6 @@ dev = [ "pytest-cov", "ruff", ] -plot = ["matplotlib"] docs = [ "jupyter-book>=1,<2",