├── .github └── workflows │ └── build-gh-pages.yaml ├── .gitignore ├── LICENSE ├── README.md ├── Tutorial 0 - Overview.ipynb ├── Tutorial 1 - TMY Weather Data.ipynb ├── Tutorial 2 - POA Irradiance.ipynb ├── Tutorial 3 - Module Temperature.ipynb ├── Tutorial 4 - Model a Module's Performance.ipynb ├── Tutorial 5 - Array Power.ipynb ├── Tutorial A - Single Diode Model.ipynb ├── Tutorial B - pvfree.ipynb ├── _config.yml ├── _toc.yml ├── images ├── pvfree_table.png ├── t1_DHI.PNG ├── t1_DNI.PNG ├── t1_GHI.PNG ├── t2_POA.PNG ├── t2_solarpanel_directions.PNG ├── t4_PANOverview.PNG ├── t4_PVEducation_IVCurve.PNG ├── t4_SingleDiodeEquation.PNG ├── t4_SingleDiodeParameterBehavior_to_TemperatureandIrradiance.PNG ├── tracker-animation-backtrack-compressed.gif ├── tracker-animation-truetrack-compressed.gif ├── tutorial_0_kevin.PNG ├── tutorial_0_mark.PNG ├── tutorial_0_silvana.PNG ├── tutorial_1_DNIDHIGHI.PNG ├── tutorial_1_NREL_DNI_Insolationmap_Year.PNG ├── tutorial_1_NREL_GHI_Insolationmap_June.PNG ├── tutorial_1_NREL_GHI_Insolationmap_Year.PNG ├── tutorial_1_NSRDB_example.PNG ├── tutorial_1_SRRL.PNG ├── tutorial_1_overview.PNG ├── tutorial_1_tmy3_example.PNG ├── tutorial_2_overview.PNG ├── tutorial_3_overview.PNG ├── tutorial_4_overview.PNG ├── tutorial_banner.PNG └── tutorial_overview.PNG └── requirements.txt /.github/workflows/build-gh-pages.yaml: -------------------------------------------------------------------------------- 1 | name: deploy-book 2 | 3 | # Only run this when the main branch changes 4 | on: 5 | push: 6 | branches: 7 | - main 8 | 9 | # This job installs dependencies, build the book, and pushes it to `gh-pages` 10 | jobs: 11 | deploy-book: 12 | runs-on: ubuntu-latest 13 | steps: 14 | - uses: actions/checkout@v2 15 | 16 | # Install dependencies 17 | - name: Set up Python 3.7 18 | uses: actions/setup-python@v1 19 | with: 20 | python-version: 3.7 21 | 22 | - name: Install dependencies 23 | run: | 24 | pip install -r requirements.txt 25 | pip install jupyter-book 26 | 27 | # Build the book 28 | - name: Build the book 29 | run: | 30 | jupyter-book build . 31 | 32 | # Push the book's HTML to github-pages 33 | - name: GitHub Pages action 34 | uses: peaceiris/actions-gh-pages@v3.6.1 35 | with: 36 | github_token: ${{ secrets.GITHUB_TOKEN }} 37 | publish_dir: ./_build/html -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .ipynb_checkpoints 2 | *.py 3 | *.html 4 | 5 | _build/ 6 | venv/ 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright (c) 2020, Mark Mikofski 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright notice, this 10 | list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright notice, 13 | this list of conditions and the following disclaimer in the documentation 14 | and/or other materials provided with the distribution. 15 | 16 | 3. Neither the name of the copyright holder nor the names of its 17 | contributors may be used to endorse or promote products derived from 18 | this software without specific prior written permission. 19 | 20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![tutorialpromo](images/tutorial_banner.PNG) 2 | 3 | # PVSC48-Python-Tutorial 4 | PVSC48 computing tutorial with focus on PV computing packages, Python, data 5 | wrangling with Pandas, and data viz 6 | 7 | ## Tutorial Summary: 8 | * **Tutorial 0**: Introduction to the tutorial, the lesson plan, and resources (~30 minutes) 9 | * **Tutorial 1**: Access TMY weather data and visualize monthly irradiance data (~30 minutes) 10 | * **Tutorial 2**: Calculate solar position, plane-of-array irradiance, and 11 | visualize average daily insolation (30 minutes) 12 | * **Tutorial 3**: Estimate module temperature from ambient (~20 minutes) 13 | * **Tutorial 4**: Use POA irradiance and module temperature to model output power 14 | from a single module (~20 minutes) 15 | * **Tutorial 5**: Combine modules to form strings, calculate inverter efficiency 16 | and total array output (~independent study) 17 | * **Tutorials Appendices**: More tutorials on a variety of fun topics (~independent study) 18 | 19 | ## Tutorial Setup 20 | These tutorials are designed to run on [Jupyter](https://jupyter.org), a 21 | browser based interactive notebook that allows you to run the tutorial in the 22 | cloud without any additional setup. On the day of the tutorial, you can log 23 | into the tutorial [here](https://pvsc-python-tutorial.eastus.cloudapp.azure.com/). 24 | 25 | ### THIS IS A 2-STEP PROCESS 26 | 27 | - **STEP 1**: click [this](https://pvsc-python-tutorial.eastus.cloudapp.azure.com/) --> https://pvsc-python-tutorial.eastus.cloudapp.azure.com/ 28 | - **STEP 2**: click [this](https://pvsc-python-tutorial.eastus.cloudapp.azure.com/hub/user-redirect/git-pull?repo=https://github.com/PVSC-Python-Tutorials/PVSC48-Python-Tutorial&branch=main) --> https://pvsc-python-tutorial.eastus.cloudapp.azure.com/hub/user-redirect/git-pull?repo=https://github.com/PVSC-Python-Tutorials/PVSC48-Python-Tutorial&branch=main 29 | 30 | The first time you visit the tutorial, you will need to create an account. Use 31 | any username and password you like. 32 | 33 | ![jupyter login](https://user-images.githubusercontent.com/1385621/119911747-c9bd3600-bf0e-11eb-8f7b-c622d8890f04.png) 34 | 35 | The first time you log into the tutorial, you will only see the scratch and shared-data folders. 36 | 37 | ![first login](https://user-images.githubusercontent.com/1385621/119912003-5cf66b80-bf0f-11eb-874d-67ba2ff1bb66.png) 38 | 39 | After you log in, you need to download the tutorial from this GitHub repository by following this 40 | [link](https://pvsc-python-tutorial.eastus.cloudapp.azure.com/hub/user-redirect/git-pull?repo=https://github.com/PVSC-Python-Tutorials/PVSC48-Python-Tutorial&branch=main): 41 | 42 | You only need to download the repository once, but you can always use either link to start the tutorial during the conference. 43 | From now on you will see the PVSC48-Python-Tutorial folder in the list. 44 | 45 | ![download tutorial](https://user-images.githubusercontent.com/1385621/119912192-ce361e80-bf0f-11eb-8f62-36e54509fdcc.png) 46 | 47 | Click the folder to open, and you'll see the full list. Click `Tutorial 0 - Overview.ipynb` to get started. 48 | 49 | ![full list of tutorials](https://user-images.githubusercontent.com/1385621/119912314-15241400-bf10-11eb-8a2c-1fc371e0f4e8.png) 50 | 51 | Sometimes, if you are idle too long, the tutorial dies. Just click the [link to the tutorial](https://pvsc-python-tutorial.eastus.cloudapp.azure.com/) again to reconnect. 52 | 53 | https://pvsc-python-tutorial.eastus.cloudapp.azure.com/ 54 | 55 | ### Jupyter Book docs 56 | 57 | The full tutorial is now also hosted as a beautiful [Jupyter book](https://jupyterbook.org/intro.html). This book has navigation, search, and can even run code cells interactively. Check it out! 58 | 59 | https://pvsc-python-tutorials.github.io/PVSC48-Python-Tutorial/index.html 60 | 61 | ### My Binder 62 | 63 | After the conference the tutorials will remain available here on GitHub, and you can run 64 | the tutorial anytime in [Binder](https://mybinder.org) by clicking the 65 | following link: 66 | 67 | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PVSC-Python-Tutorials/PVSC48-Python-Tutorial/main) 68 | 69 | ### Locally 70 | 71 | You can also run the tutorial locally with 72 | [miniconda](https://docs.conda.io/en/latest/miniconda.html) by following thes 73 | steps: 74 | 75 | 1. Install [miniconda](https://docs.conda.io/en/latest/miniconda.html). 76 | 77 | 1. Clone the repository: 78 | 79 | ``` 80 | git clone https://github.com/PVSC-Python-Tutorials/PVSC48-Python-Tutorial.git 81 | ``` 82 | 83 | 1. Create the environment and install the requirements. The repository includes 84 | a `requirements.txt` file that contains a list the packages needed to run 85 | this tutorial. To install them using conda run: 86 | 87 | ``` 88 | conda create -n pvsc48 jupyter -c pvlib --file requirements.txt 89 | conda activate pvsc48 90 | ``` 91 | 92 | 1. Start a Jupyter session: 93 | 94 | ``` 95 | jupyter notebook 96 | ``` 97 | 98 | 1. Use the file explorer in Jupyter lab to browse to `PVSC48-Python-Tutorial` 99 | and start the first Tutorial. 100 | 101 | 102 | ### Licensing 103 | 104 | Creative Commons License
This work is licensed under a Creative Commons Attribution 4.0 International License. 105 | -------------------------------------------------------------------------------- /Tutorial 0 - Overview.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "![tutorial banner](images/tutorial_banner.PNG)\n", 12 | "\n", 13 | "\n", 14 | "# Welcome! \n", 15 | "\n", 16 | "Welcome to the PV Software 101: from Sun position to AC Output! tutorial\n", 17 | "\n", 18 | "Modeling tools for all aspects of photovoltaic systems are rapidly growing, and there are solutions for many of the things you might want to simulate. Python is becoming one of the scientific languages of choice, and many open-source tools are available for PV modeling. This tutorial will focus on teaching attendees PV modeling in python through the use of PVlib. \n", 19 | "\n", 20 | "In this interactive tutorial we will go from getting acquainted with some common data used or measured in pv systems (i.e. weather), to modeling the AC energy output of a single-axis tracker system. This includes learning and simulating sun position, plane of array irradiances, temperature models, single-diode models and more. \n", 21 | "\n", 22 | "We will review common vocabulary around python and ``data aggregation`` by hour, week, month, and visualization. \n", 23 | "\n", 24 | "The tutorial will present hands-on examples in python, enabled via jupyter notebooks and a Jupyterhub (remote hosted server for jupyter notebooks and python language) so you, the attendee, don’t have to install anything, and can follow along while we go over the theory and code! In case it's not obvious, a computer is required. \n", 25 | "\n", 26 | "The tutorial will wrap up with an overview of other available open-source tools for other aspects of modeling PV systems. \n" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## More on your teachers:\n", 34 | "\n", 35 | "The three of us have ample experience in data, coding, and PV field performance modeling, so we look forward to all of your questions.\n", 36 | "\n", 37 | "| | |\n", 38 | "| --- | :--- |\n", 39 | "| ![Mark Mikofski](images/tutorial_0_mark.PNG) |

Mark Mikofski


I am a principal solar engineer at DNV and product manager for SolarFarmer. I research, analyze, and predict PV system performance, degradation, and reliability. I have contributed to a few Python projects like [pvlib python](https://pvlib-python.readthedocs.io/en/latest/), [PVMismatch](https://sunpower.github.io/PVMismatch/), and [SciPy](https://scipy.org/) |\n", 40 | "| ![Silvana Ayala Pelaez](images/tutorial_0_silvana.PNG) |

Silvana Ayala Pelaez


I am a research scientist at NREL, focusing mostly on bifacial PV system's performance, and circular economy. Python is my daily bread and butter for data analysis and building tools. Silvana has made substantial contributions to the NREL [bifacialvf pvmismatch](https://github.com/NREL/bifacialvf) and [bifacial radiance](https://bifacial-radiance.readthedocs.io/en/latest/) software packages. |\n", 41 | "| ![Kevin Anderson](images/tutorial_0_kevin.PNG) |

Kevin Anderson


I am a research scientist at NREL doing cool stuff! I have contributed to work on slope aware backtracking, clipping loss errors in hourly yield estimates, and am a maintainer for [pvlib python](https://pvlib-python.readthedocs.io/en/latest/) and a frequent contributor to [RdTools](https://rdtools.readthedocs.io/en/latest/). |" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": { 47 | "slideshow": { 48 | "slide_type": "slide" 49 | } 50 | }, 51 | "source": [ 52 | "## Learning Objectives\n", 53 | "\n", 54 | "1.\tAccess weather data (TMY3), understand irradiance data, and visualize it monthly.\n", 55 | "2.\tCalculate sun position, plane of array irradiance, and aggregate irradiance data into average daily insolation by month and year.\n", 56 | "3.\tCalculate module temperature from ambient data. \n", 57 | "4.\tUse POA and module temperature to forecast a module's performance. \n", 58 | "\n", 59 | "## Overview\n", 60 | "The sketch below from [the Sandia PV Performance Modeling Collaborative (PVPMC)](https://pvpmc.sandia.gov/) outlines the topics we will cover in this tutorial:\n", 61 | "\n", 62 | "![Overview](images/tutorial_overview.PNG)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": { 68 | "slideshow": { 69 | "slide_type": "subslide" 70 | } 71 | }, 72 | "source": [ 73 | "### Why learn this? \n", 74 | "\n", 75 | "PV-lib is a library of algorithms and routines that you might encounter the need to use if you're doing anything PV-modeling related. It is managed by members of the PV research community, who make sure the formulas and code are not only sleek but accurate. \n", 76 | "\n", 77 | "* You want to know the sun position? No need to code from zero the SPA (Solar Position algorithm), it's in PVlib. \n", 78 | "\n", 79 | "* You want to reproduce the Sandia-King model to calculate module performance? It's there, also. \n", 80 | "\n", 81 | "* You can find the most well-known [models](https://pvpmc.sandia.gov/), as well as recently accepted values and approaches in published PV literature.\n", 82 | "\n", 83 | "* We hope adding this tool to your skillset will empower you to do better, faster research with an already solid foundation. Don't reinvent the wheel!" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": { 89 | "slideshow": { 90 | "slide_type": "slide" 91 | } 92 | }, 93 | "source": [ 94 | "## How to use this tutorial?\n", 95 | "\n", 96 | "This tutorial is a [Jupyter](https://jupyter.org) notebook. Jupyter is a browser based interactive tool that combines text, images, equations, and code that can be shared with others. Please see the setup section in the [README](./README.md) to learn more about how to get started." 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": { 102 | "slideshow": { 103 | "slide_type": "slide" 104 | } 105 | }, 106 | "source": [ 107 | "## Useful links\n", 108 | "\n", 109 | "1. References\n", 110 | " * [PVlib Documentation](https://pvlib-python.readthedocs.io/en/stable/)\n", 111 | " * [Github Code Repository](https://github.com/pvlib/pvlib-python)\n", 112 | "2. Ask for help:\n", 113 | " * [Use the pvlib-python tag on StackOverflow](https://stackoverflow.com/questions/tagged/pvlib-python)\n", 114 | " * [Google Group - Discussions and more!](https://groups.google.com/g/pvlib-python)\n", 115 | " * [Open an Issue on the Github Repository](https://github.com/pyvlib/pvlib-python/issues)" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": { 121 | "slideshow": { 122 | "slide_type": "slide" 123 | } 124 | }, 125 | "source": [ 126 | "## Tutorial Structure\n", 127 | "\n", 128 | "This tutorial is made up of multiple Jupyter Notebooks. These notebooks mix\n", 129 | "code, text, visualization, and exercises.\n", 130 | "\n", 131 | "If you haven't used JupyterLab before, it's similar to the Jupyter Notebook. If\n", 132 | "you haven't used the Notebook, the quick intro is\n", 133 | "\n", 134 | "1. There are two modes: ``command`` and ``edit``\n", 135 | "\n", 136 | "1. From ``command`` mode, press `Enter` to edit a cell (like this markdown cell)\n", 137 | "\n", 138 | "1. From ``edit`` mode, press `Esc` to change to command mode\n", 139 | "1. Press `shift+enter` to execute a cell and move to the next cell.\n", 140 | "1. The toolbar has commands for executing, converting, and creating cells.\n", 141 | "\n", 142 | "The layout of the tutorial will be as follows:\n", 143 | "\n" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": { 149 | "slideshow": { 150 | "slide_type": "slide" 151 | } 152 | }, 153 | "source": [ 154 | "## Exercise: Print Hello, world!\n", 155 | "\n", 156 | "Each notebook will have exercises for you to solve. You'll be given a blank or\n", 157 | "partially completed cell, followed by a hidden cell with a solution. For\n", 158 | "example.\n", 159 | "\n", 160 | "Print the text \"Hello, world!\".\n" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 1, 166 | "metadata": { 167 | "slideshow": { 168 | "slide_type": "subslide" 169 | } 170 | }, 171 | "outputs": [ 172 | { 173 | "name": "stdout", 174 | "output_type": "stream", 175 | "text": [ 176 | "Hello, world!\n" 177 | ] 178 | } 179 | ], 180 | "source": [ 181 | "# Your code here\n", 182 | "print(\"Hello, world!\")" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "## Exercise 1: Modify to print something else:" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [ 198 | "my_string = # Add your text here. Remember to put it inside of single quotes or double quotes ( \" \" or '' )\n", 199 | "print(my_string)" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "## Let's go over some Python Concepts\n", 207 | "\n", 208 | "(A lot of this examples were shamely taken from https://jckantor.github.io/CBE30338/01.01-Getting-Started-with-Python-and-Jupyter-Notebooks.html :$)\n", 209 | "\n", 210 | "\n", 211 | "## Basic Arithmetic Operations\n", 212 | "\n", 213 | "Basic arithmetic operations are built into the Python langauge. Here are some examples. In particular, note that exponentiation is done with the ** operator." 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 3, 219 | "metadata": { 220 | "slideshow": { 221 | "slide_type": "subslide" 222 | } 223 | }, 224 | "outputs": [ 225 | { 226 | "name": "stdout", 227 | "output_type": "stream", 228 | "text": [ 229 | "5\n", 230 | "8\n", 231 | "0.6666666666666666\n" 232 | ] 233 | } 234 | ], 235 | "source": [ 236 | "a = 2\n", 237 | "b = 3\n", 238 | "print(a + b)\n", 239 | "print(a ** b)\n", 240 | "print(a / b)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": {}, 246 | "source": [ 247 | "## Python Libraries\n", 248 | "\n", 249 | "The Python language has only very basic operations. Most math functions are in various math libraries. The numpy library is convenient library. This next cell shows how to import numpy with the prefix np, then use it to call a common mathematical functions." 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 7, 255 | "metadata": {}, 256 | "outputs": [ 257 | { 258 | "name": "stdout", 259 | "output_type": "stream", 260 | "text": [ 261 | "3.141592653589793\n", 262 | "2.718281828459045\n", 263 | "0.7071067811865476\n", 264 | "0.7071067811865476\n", 265 | "0.9999999999999999\n" 266 | ] 267 | } 268 | ], 269 | "source": [ 270 | "import numpy as np\n", 271 | "\n", 272 | "# mathematical constants\n", 273 | "print(np.pi)\n", 274 | "print(np.e)\n", 275 | "\n", 276 | "# trignometric functions\n", 277 | "angle = np.pi/4\n", 278 | "print(np.sin(angle))\n", 279 | "print(np.cos(angle))\n", 280 | "print(np.tan(angle))" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "Lists are a versatile way of organizing your data in Python. Here are some examples, more can be found on this Khan Academy video." 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": 6, 293 | "metadata": {}, 294 | "outputs": [ 295 | { 296 | "data": { 297 | "text/plain": [ 298 | "[1, 2, 3, 4]" 299 | ] 300 | }, 301 | "execution_count": 6, 302 | "metadata": {}, 303 | "output_type": "execute_result" 304 | } 305 | ], 306 | "source": [ 307 | "xList = [1, 2, 3, 4]\n", 308 | "xList" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "## Concatenation\n", 316 | "\n", 317 | "Concatentation is the operation of joining one list to another." 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 5, 323 | "metadata": {}, 324 | "outputs": [ 325 | { 326 | "data": { 327 | "text/plain": [ 328 | "[1, 2, 3, 4, 5, 6, 7, 8]" 329 | ] 330 | }, 331 | "execution_count": 5, 332 | "metadata": {}, 333 | "output_type": "execute_result" 334 | } 335 | ], 336 | "source": [ 337 | "x = [1, 2, 3, 4];\n", 338 | "y = [5, 6, 7, 8];\n", 339 | "\n", 340 | "x + y" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": 8, 346 | "metadata": {}, 347 | "outputs": [ 348 | { 349 | "data": { 350 | "text/plain": [ 351 | "10" 352 | ] 353 | }, 354 | "execution_count": 8, 355 | "metadata": {}, 356 | "output_type": "execute_result" 357 | } 358 | ], 359 | "source": [ 360 | "np.sum(x)" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "## Loops" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": 9, 373 | "metadata": {}, 374 | "outputs": [ 375 | { 376 | "name": "stdout", 377 | "output_type": "stream", 378 | "text": [ 379 | "sin(1) = 0.84147\n", 380 | "sin(2) = 0.90930\n", 381 | "sin(3) = 0.14112\n", 382 | "sin(4) = -0.75680\n" 383 | ] 384 | } 385 | ], 386 | "source": [ 387 | "for x in xList:\n", 388 | " print(\"sin({0}) = {1:8.5f}\".format(x,np.sin(x)))" 389 | ] 390 | }, 391 | { 392 | "cell_type": "markdown", 393 | "metadata": {}, 394 | "source": [ 395 | "## Working with Dictionaries\n", 396 | "\n", 397 | "Dictionaries are useful for storing and retrieving data as key-value pairs. For example, here is a short dictionary of molar masses. The keys are molecular formulas, and the values are the corresponding molar masses.\n" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": 10, 403 | "metadata": {}, 404 | "outputs": [ 405 | { 406 | "data": { 407 | "text/plain": [ 408 | "{'Arizona': 16.04, 'California': 30.02, 'Texas': 18.0, 'Colorado': 44.01}" 409 | ] 410 | }, 411 | "execution_count": 10, 412 | "metadata": {}, 413 | "output_type": "execute_result" 414 | } 415 | ], 416 | "source": [ 417 | "States_SolarInstallations2020 = {'Arizona': 16.04, 'California': 30.02, 'Texas':18.00, 'Colorado': 44.01} # GW\n", 418 | "States_SolarInstallations2020" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "We can a value to an existing dictionary.\n" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": 11, 431 | "metadata": {}, 432 | "outputs": [], 433 | "source": [ 434 | "States_SolarInstallations2020['New Mexico'] = 22.4\n" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "metadata": {}, 440 | "source": [ 441 | "## Plotting\n", 442 | "\n", 443 | "Importing the matplotlib.pyplot library gives IPython notebooks plotting functionality very similar to Matlab's. Here are some examples using functions from the" 444 | ] 445 | }, 446 | { 447 | "cell_type": "code", 448 | "execution_count": 2, 449 | "metadata": {}, 450 | "outputs": [ 451 | { 452 | "data": { 453 | "image/png": "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\n", 454 | "text/plain": [ 455 | "
" 456 | ] 457 | }, 458 | "metadata": { 459 | "needs_background": "light" 460 | }, 461 | "output_type": "display_data" 462 | } 463 | ], 464 | "source": [ 465 | "%matplotlib inline\n", 466 | "\n", 467 | "import matplotlib.pyplot as plt\n", 468 | "import numpy as np\n", 469 | "\n", 470 | "x = np.linspace(0,10)\n", 471 | "y = np.sin(x)\n", 472 | "z = np.cos(x)\n", 473 | "\n", 474 | "plt.plot(x,y,'b',x,z,'r')\n", 475 | "plt.xlabel('Radians');\n", 476 | "plt.ylabel('Value');\n", 477 | "plt.title('Plotting Demonstration')\n", 478 | "plt.legend(['Sin','Cos'])\n", 479 | "plt.grid()" 480 | ] 481 | }, 482 | { 483 | "cell_type": "markdown", 484 | "metadata": { 485 | "slideshow": { 486 | "slide_type": "skip" 487 | } 488 | }, 489 | "source": [ 490 | "## Going Deeper\n", 491 | "\n", 492 | "We've designed the notebooks above to cover the basics of pvlib from beginning\n", 493 | "to end. To help you go deeper, we've also create a list of notebooks that\n", 494 | "demonstrate real-world applications of pvlib in a variety of use cases. These\n", 495 | "need not be explored in any particular sequence, instead they are meant to\n", 496 | "provide a sampling of what pvlib can be used for.\n", 497 | "\n", 498 | "### PVLIB and Weather/Climate Model Data\n", 499 | "\n", 500 | "Check out the pvlib python [examples gallery](https://pvlib-python.readthedocs.io/en/stable/auto_examples/index.html).\n", 501 | "Start with [Sun path diagram](https://pvlib-python.readthedocs.io/en/stable/auto_examples/plot_sunpath_diagrams.html),\n", 502 | "then feel free to explore the rest of the notebooks.\n", 503 | "\n", 504 | "### Open PV Tools\n", 505 | "\n", 506 | "There is a curated list of [open source PV tools](https://openpvtools.readthedocs.io/) from [\"Review of Open Source Tools for PV Modeling\" by Will Holmgren, _et al._ at IEEE 7th World Conference on PV Energy Conversion 2018](http://dx.doi.org/10.1109/PVSC.2018.8548231)." 507 | ] 508 | }, 509 | { 510 | "cell_type": "markdown", 511 | "metadata": {}, 512 | "source": [ 513 | "[![Creative Commons License](https://i.creativecommons.org/l/by/4.0/88x31.png)](http://creativecommons.org/licenses/by/4.0/)\n", 514 | "\n", 515 | "This work is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/)." 516 | ] 517 | } 518 | ], 519 | "metadata": { 520 | "kernelspec": { 521 | "display_name": "Python 3", 522 | "language": "python", 523 | "name": "python3" 524 | }, 525 | "language_info": { 526 | "codemirror_mode": { 527 | "name": "ipython", 528 | "version": 3 529 | }, 530 | "file_extension": ".py", 531 | "mimetype": "text/x-python", 532 | "name": "python", 533 | "nbconvert_exporter": "python", 534 | "pygments_lexer": "ipython3", 535 | "version": "3.7.10" 536 | } 537 | }, 538 | "nbformat": 4, 539 | "nbformat_minor": 4 540 | } 541 | -------------------------------------------------------------------------------- /Tutorial 3 - Module Temperature.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "![tutorialpromo](images/tutorial_banner.PNG)\n", 8 | "\n", 9 | "\n", 10 | "# Tutorial 3 - Module Temperature\n", 11 | "\n", 12 | "This notebook shows how to use pvlib to estimate PV cell temperature, a secondary driver that affects the PV conversion efficiency.\n", 13 | "\n", 14 | "![Overview](images/tutorial_3_overview.PNG)\n", 15 | "\n" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## PV Concepts in this lesson:\n", 23 | "\n", 24 | "* cell and module temperature\n", 25 | "* NSRDB data\n", 26 | "* TMY files\n", 27 | "\n", 28 | "## Python concepts in this lesson:\n", 29 | "\n", 30 | "* file system paths in Python with [`pathlib`](https://docs.python.org/3/library/pathlib.html)\n", 31 | "* parsing NSRDB data with [`pvlib.iotools.read_tmy3`](https://pvlib-python.readthedocs.io/en/stable/generated/pvlib.iotools.read_tmy3.html)\n", 32 | "* dates, times, and timedeltas in Python\n", 33 | "* solar position with [`pvlib.solarposition.get_solarposition`](https://pvlib-python.readthedocs.io/en/stable/generated/pvlib.solarposition.get_solarposition.html)\n", 34 | "* single-axis tracking in [`pvlib.tracking.singleaxis`](https://pvlib-python.readthedocs.io/en/stable/generated/pvlib.tracking.singleaxis.html) -- check out this [singleaxis tracking example](https://pvlib-python.readthedocs.io/en/stable/auto_examples/plot_single_axis_tracking.html#sphx-glr-auto-examples-plot-single-axis-tracking-py) in the gallery\n", 35 | "* [calculate module cell temperature with Sandia Array Performance Model (SAPM)](https://pvlib-python.readthedocs.io/en/stable/generated/pvlib.temperature.sapm_cell.html)\n", 36 | "* making [matplotlib scatterplots](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html) with a [colorbar](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.colorbar.html)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "## What affects module temperature?\n", 44 | "\n", 45 | "If PV modules were 100% efficient, they would convert 100% of collected irradiance into electrical energy. However, today's PV modules are on the order of 20% efficient, meaning that after accounting for reflection, soiling, spectral mismatch, and the glass, the other 80% of sunlight collected is converted to thermal energy. This thermal energy causes the temperature of the module to rise above ambient conditions, eventually reaching a steady state defined by a heat balance of power in (solar irradiance) vs power out (thermal radiation, convective cooling, etc). With that in mind, the primary drivers of module temperature are POA irradiance, ambient temperature, and wind speed. \n", 46 | "\n", 47 | "A distinction that is often ignored is the difference between module temperature and cell temperature. In theory, the temperature of the P-N junction inside the cell is what affects conversion efficiency, but this is difficult to measure. In practice, the temperature of the module backsheet is often a usable approximation, though it is often 1-2 degrees Celsius cooler than the junction temperature.\n", 48 | "\n", 49 | "## Modeling module temperature\n", 50 | "\n", 51 | "Some PV thermal models go to the trouble of modeling the entire heat balance equation, but much simpler models are available and are often accurate enough. Here we will use the thermal model from the Sandia Array Performance Model (SAPM) to estimate cell temperature from ambient conditions. The SAPM thermal model takes only POA irradiance, ambient temperature, and wind speed as weather inputs, but it also requires a set of parameters that characterize the thermal properties of the module of interest. More on that later.\n", 52 | "\n", 53 | "First, let's use the procedure of previous tutorials to get the relevant inputs for a tracking array:" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 1, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "name": "stdout", 63 | "output_type": "stream", 64 | "text": [ 65 | "0.8.0\n" 66 | ] 67 | } 68 | ], 69 | "source": [ 70 | "import pvlib\n", 71 | "import pandas as pd # for data wrangling\n", 72 | "import matplotlib.pyplot as plt # for visualization\n", 73 | "import pathlib # for finding the example dataset\n", 74 | "\n", 75 | "print(pvlib.__version__)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 2, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "# create a path to the pvlib \"data\" folder using Python pathlib,\n", 85 | "# note how you can use `.__file__` to get the path to the pvlib module,\n", 86 | "# the `.parent` attribute to get the directory containing a file,\n", 87 | "# and \"/\" operator add nested folders to the path. Then read a TMY3 file\n", 88 | "# that comes with pvlib python in the \"data\" folder, coercing the year to 1990\n", 89 | "DATA_DIR = pathlib.Path(pvlib.__file__).parent / 'data'\n", 90 | "df_tmy, metadata = pvlib.iotools.read_tmy3(DATA_DIR / '723170TYA.CSV', coerce_year=1990)\n", 91 | "\n", 92 | "# pvlib iotools.read_tmy3 returns a Pandas DataFrame of the timeseries\n", 93 | "# and dictionary of metadata. Use the coordinates of the TMY3 file to\n", 94 | "# create a pvlib python \"location\"\n", 95 | "location = pvlib.location.Location(\n", 96 | " latitude=metadata['latitude'], longitude=metadata['longitude'])\n", 97 | "\n", 98 | "# offset the hourly timeseries by 30-minutes to get the solar positions at the\n", 99 | "# center of each interval\n", 100 | "times = df_tmy.index - pd.Timedelta('30min')\n", 101 | "solar_position = location.get_solarposition(times)\n", 102 | "# shift the times to the right side of each interval\n", 103 | "solar_position.index += pd.Timedelta('30min')\n", 104 | "\n", 105 | "# calculate the positions at each timestep for a north-south aligned tracker\n", 106 | "# note by default backtrack is true and GCR = 1/7\n", 107 | "tracker_data = pvlib.tracking.singleaxis(\n", 108 | " solar_position['apparent_zenith'], solar_position['azimuth'], axis_azimuth=180)\n", 109 | "# set nighttime tracker positions to stow (zero-degrees is horizontal)\n", 110 | "tilt = tracker_data['surface_tilt'].fillna(0)\n", 111 | "azimuth = tracker_data['surface_azimuth'].fillna(0)\n", 112 | "\n", 113 | "# get the irradiance components in the plane of the array at each timestep\n", 114 | "df_poa_tracker = pvlib.irradiance.get_total_irradiance(\n", 115 | " surface_tilt=tilt,\n", 116 | " surface_azimuth=azimuth,\n", 117 | " dni=df_tmy['DNI'],\n", 118 | " ghi=df_tmy['GHI'],\n", 119 | " dhi=df_tmy['DHI'],\n", 120 | " solar_zenith=solar_position['apparent_zenith'],\n", 121 | " solar_azimuth=solar_position['azimuth'])\n", 122 | "tracker_poa = df_poa_tracker['poa_global']" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "Now that we have the necessary weather inputs, all that is left are the thermal parameters. These characterize the thermal properties of the module as well as the module's mounting configuration. Parameter values covering the common system designs are provided with pvlib:" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 3, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "data": { 139 | "text/plain": [ 140 | "['open_rack_glass_glass',\n", 141 | " 'close_mount_glass_glass',\n", 142 | " 'open_rack_glass_polymer',\n", 143 | " 'insulated_back_glass_polymer']" 144 | ] 145 | }, 146 | "execution_count": 3, 147 | "metadata": {}, 148 | "output_type": "execute_result" 149 | } 150 | ], 151 | "source": [ 152 | "all_parameters = pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']\n", 153 | "list(all_parameters.keys())" 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "`open_rack_glass_polymer` is appropriate for many large-scale systems (polymer backsheet; open racking), so we will use it here:" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 4, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [ 169 | "parameters = all_parameters['open_rack_glass_polymer']\n", 170 | "# note the \"splat\" operator \"**\" which expands the dictionary \"parameters\"\n", 171 | "# into a comma separated list of keyword arguments\n", 172 | "cell_temperature = pvlib.temperature.sapm_cell(\n", 173 | " tracker_poa, df_tmy['DryBulb'], df_tmy['Wspd'], **parameters)" 174 | ] 175 | }, 176 | { 177 | "cell_type": "markdown", 178 | "metadata": {}, 179 | "source": [ 180 | "Now let's compare ambient temperature with cell temperature. Notice how our modeled cell temperature rises significantly above ambient temperature during the day, especially on sunny days:" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 5, 186 | "metadata": {}, 187 | "outputs": [ 188 | { 189 | "data": { 190 | "image/png": "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\n", 191 | "text/plain": [ 192 | "
" 193 | ] 194 | }, 195 | "metadata": { 196 | "needs_background": "light" 197 | }, 198 | "output_type": "display_data" 199 | } 200 | ], 201 | "source": [ 202 | "df_tmy['DryBulb'].head(24*7).plot()\n", 203 | "cell_temperature.head(24*7).plot()\n", 204 | "plt.grid()\n", 205 | "plt.legend(['Dry Bulb', 'Cell Temperature'])\n", 206 | "# note Python 3 can use unicode characters like the degrees symbol\n", 207 | "plt.ylabel('Temperature [°C]');" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "Wind speed also has an effect, but it's harder to see in a time series plot like this. To make it clearer, let's make a scatter plot: " 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 6, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "data": { 224 | "image/png": "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\n", 225 | "text/plain": [ 226 | "
" 227 | ] 228 | }, 229 | "metadata": { 230 | "needs_background": "light" 231 | }, 232 | "output_type": "display_data" 233 | } 234 | ], 235 | "source": [ 236 | "temperature_difference = cell_temperature - df_tmy['DryBulb']\n", 237 | "plt.scatter(tracker_poa, temperature_difference, c=df_tmy['Wspd'])\n", 238 | "plt.colorbar()\n", 239 | "# note you can use LaTeX math in matplotlib labels\n", 240 | "# compare \\degree\" with the unicode symbol above\n", 241 | "plt.ylabel('Temperature rise above ambient [$\\degree C$]')\n", 242 | "plt.xlabel('POA Irradiance [$W/m^2$]');\n", 243 | "plt.title('Cell temperature rise, colored by wind speed');" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "metadata": {}, 249 | "source": [ 250 | "The main trend is a bigger temperature difference as incident irradiance increases. However, this plot shows that higher wind speed reduces the effect -- faster wind means more convective cooling, so a lower cell temperature than it would be in calm air.\n", 251 | "\n", 252 | "Note: the gap at the upper edge of the trend is an artifact of the low resolution of wind speed values in this TMY dataset; there are no values between 0 and 0.3 m/s." 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": {}, 258 | "source": [ 259 | "## Pop Quiz\n", 260 | "Now it's your turn. There's another, older TMY3 file in the pvlib data folder: \"703165TY.csv\".\n", 261 | "1. Create a path to the TMY3 file: \"703165TY.csv\" using `DATA_DIR` and the `/` operator\n", 262 | "2. read the timeseries and metadata from the file\n", 263 | "3. What is the name of the station in the metadata?\n", 264 | "4. Assuming a glass polymer module on a horizontally flat rooftop, use the SAPM to calculate the cell temperature\n", 265 | " - What is the plane of array irradiance incident on the horizontal rooftop module?\n", 266 | " - What parameters should be used for a rooftop module?\n", 267 | "5. In the same plot compare the first week of ambient temperature data with the calculated cell temperatures" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 7, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "mypath = DATA_DIR / 'path to TMY3 file goes here'\n", 277 | "# now use pvlib.iotools.read_tmy3 to get the data, what station is it?\n" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 8, 283 | "metadata": {}, 284 | "outputs": [], 285 | "source": [ 286 | "# make a plot of the 1st week ambient & calculated cell temperatures\n" 287 | ] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "[![Creative Commons License](https://i.creativecommons.org/l/by/4.0/88x31.png)](http://creativecommons.org/licenses/by/4.0/)\n", 294 | "\n", 295 | "This work is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/)." 296 | ] 297 | } 298 | ], 299 | "metadata": { 300 | "kernelspec": { 301 | "display_name": "Python 3", 302 | "language": "python", 303 | "name": "python3" 304 | }, 305 | "language_info": { 306 | "codemirror_mode": { 307 | "name": "ipython", 308 | "version": 3 309 | }, 310 | "file_extension": ".py", 311 | "mimetype": "text/x-python", 312 | "name": "python", 313 | "nbconvert_exporter": "python", 314 | "pygments_lexer": "ipython3", 315 | "version": "3.7.10" 316 | } 317 | }, 318 | "nbformat": 4, 319 | "nbformat_minor": 4 320 | } 321 | -------------------------------------------------------------------------------- /Tutorial B - pvfree.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "![tutorialpromo](images/tutorial_banner.PNG)\n", 8 | "\n", 9 | "\n", 10 | "# Tutorial B - pvfree\n", 11 | "\n", 12 | "Another option to get CEC module parameters is to use [pvfree](https://pvfree.azurewebsites.net/). \n", 13 | "\n", 14 | "
\n", 15 | "Let's Explore: Click here to see the pvfree Website
\n", 16 | "\n", 17 | "![pvfree_table](images/pvfree_table.png)\n", 18 | "\n", 19 | "You can search the table of the [CEC modules](https://pvfree.azurewebsites.net/cec_modules/). Once you find the desired module, you can get a JSON dictionary of the CEC module parameters from the API. For example, [Canadian Solar Inc. CS5P-220M](https://pvfree.azurewebsites.net/cec_modules/1733/) can be downloaded from the API here: https://pvfree.azurewebsites.net/api/v1/cecmodule/1733/?format=json. You can copy and paste or use python to call the API. The API also has search filters you can use. For example: https://pvfree.azurewebsites.net/api/v1/cecmodule/?format=json&Name__istartswith=canadian&STC__gt=219&STC__lt=221 searches for all modules starting with \"canadian\" and with nameplate between 219-W and 221-W which returns a list of 6 modules in a JSON dictionary. Limiting the short circuit currentl (Isc) to less than 6-A reduces this list to 2 modules." 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "name": "stdout", 29 | "output_type": "stream", 30 | "text": [ 31 | "Total count of Canadian Solar 220-W with Isc < 6A: 2\n" 32 | ] 33 | }, 34 | { 35 | "data": { 36 | "text/plain": [ 37 | "[{'A_c': 1.7,\n", 38 | " 'Adjust': 8.619516,\n", 39 | " 'BIPV': False,\n", 40 | " 'Bifacial': False,\n", 41 | " 'Date': '2018-11-04',\n", 42 | " 'I_L_ref': 5.11426,\n", 43 | " 'I_mp_ref': 4.69,\n", 44 | " 'I_o_ref': 8.102508e-10,\n", 45 | " 'I_sc_ref': 5.1,\n", 46 | " 'Length': 1.602,\n", 47 | " 'N_s': 96,\n", 48 | " 'Name': 'Canadian Solar Inc. CS5P-220M',\n", 49 | " 'PTC': 200.1,\n", 50 | " 'R_s': 1.066023,\n", 51 | " 'R_sh_ref': 381.254425,\n", 52 | " 'STC': 219.961,\n", 53 | " 'T_NOCT': 42.4,\n", 54 | " 'Technology': 'Mono-c-Si',\n", 55 | " 'V_mp_ref': 46.9,\n", 56 | " 'V_oc_ref': 59.4,\n", 57 | " 'Version': 'SAM 2018.10.29',\n", 58 | " 'Width': 1.061,\n", 59 | " 'a_ref': 2.635926,\n", 60 | " 'alpha_sc': 0.004539,\n", 61 | " 'beta_oc': -0.222156,\n", 62 | " 'created_on': '2019-02-12',\n", 63 | " 'gamma_r': -0.476,\n", 64 | " 'id': 1733,\n", 65 | " 'modified_on': '2019-02-12',\n", 66 | " 'resource_uri': '/api/v1/cecmodule/1733/'},\n", 67 | " {'A_c': 1.639,\n", 68 | " 'Adjust': 2.227195,\n", 69 | " 'BIPV': False,\n", 70 | " 'Bifacial': False,\n", 71 | " 'Date': '2018-11-04',\n", 72 | " 'I_L_ref': 5.05607,\n", 73 | " 'I_mp_ref': 4.73,\n", 74 | " 'I_o_ref': 9.957448e-11,\n", 75 | " 'I_sc_ref': 5.05,\n", 76 | " 'Length': 1.579,\n", 77 | " 'N_s': 96,\n", 78 | " 'Name': 'Canadian Solar Inc. CS5P-220P',\n", 79 | " 'PTC': 193.1,\n", 80 | " 'R_s': 1.00467,\n", 81 | " 'R_sh_ref': 835.904785,\n", 82 | " 'STC': 220.418,\n", 83 | " 'T_NOCT': 51.4,\n", 84 | " 'Technology': 'Multi-c-Si',\n", 85 | " 'V_mp_ref': 46.6,\n", 86 | " 'V_oc_ref': 58.3,\n", 87 | " 'Version': 'SAM 2018.10.29',\n", 88 | " 'Width': 1.038,\n", 89 | " 'a_ref': 2.366377,\n", 90 | " 'alpha_sc': 0.0025,\n", 91 | " 'beta_oc': -0.196588,\n", 92 | " 'created_on': '2019-02-12',\n", 93 | " 'gamma_r': -0.43,\n", 94 | " 'id': 1734,\n", 95 | " 'modified_on': '2019-02-12',\n", 96 | " 'resource_uri': '/api/v1/cecmodule/1734/'}]" 97 | ] 98 | }, 99 | "execution_count": 1, 100 | "metadata": {}, 101 | "output_type": "execute_result" 102 | } 103 | ], 104 | "source": [ 105 | "import urllib, json\n", 106 | "params = urllib.parse.urlencode({\n", 107 | " 'Name__istartswith': 'canadian',\n", 108 | " 'STC__gt': 219, 'STC__lt': 221,\n", 109 | " 'I_sc_ref__lt': 6})\n", 110 | "with urllib.request.urlopen(f'https://pvfree.azurewebsites.net/api/v1/cecmodule/?{params}') as fp:\n", 111 | " cs_220_mods = json.load(fp)\n", 112 | "print(f\"Total count of Canadian Solar 220-W with Isc < 6A: {cs_220_mods['meta']['total_count']}\")\n", 113 | "cs_220_mods['objects']" 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "metadata": {}, 119 | "source": [ 120 | "[![Creative Commons License](https://i.creativecommons.org/l/by/4.0/88x31.png)](http://creativecommons.org/licenses/by/4.0/)\n", 121 | "\n", 122 | "This work is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/)." 123 | ] 124 | } 125 | ], 126 | "metadata": { 127 | "kernelspec": { 128 | "display_name": "Python 3", 129 | "language": "python", 130 | "name": "python3" 131 | }, 132 | "language_info": { 133 | "codemirror_mode": { 134 | "name": "ipython", 135 | "version": 3 136 | }, 137 | "file_extension": ".py", 138 | "mimetype": "text/x-python", 139 | "name": "python", 140 | "nbconvert_exporter": "python", 141 | "pygments_lexer": "ipython3", 142 | "version": "3.7.3" 143 | } 144 | }, 145 | "nbformat": 4, 146 | "nbformat_minor": 4 147 | } 148 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | # Book settings 2 | # Learn more at https://jupyterbook.org/customize/config.html 3 | 4 | title: PVSC 48 Python Tutorial 5 | author: Silvana Ayala Pelaez, Mark Mikofski, Kevin Anderson 6 | logo: images/tutorial_banner.PNG 7 | 8 | # Force re-execution of notebooks on each build. 9 | # See https://jupyterbook.org/content/execute.html 10 | execute: 11 | execute_notebooks: auto 12 | 13 | # Define the name of the latex output file for PDF builds 14 | latex: 15 | latex_documents: 16 | targetname: book.tex 17 | 18 | # Add a bibtex file so that we can create citations 19 | #bibtex_bibfiles: 20 | # - references.bib 21 | 22 | # Information about where the book exists on the web 23 | repository: 24 | url: https://github.com/PVSC-Python-Tutorials/PVSC48-Python-Tutorial 25 | #path_to_book: docs # Optional path to your book, relative to the repository root 26 | branch: main 27 | 28 | # Add GitHub buttons to your book 29 | # See https://jupyterbook.org/customize/config.html#add-a-link-to-your-repository 30 | html: 31 | use_issues_button: true 32 | use_repository_button: true 33 | 34 | launch_buttons: 35 | thebe: true 36 | -------------------------------------------------------------------------------- /_toc.yml: -------------------------------------------------------------------------------- 1 | # Table of contents 2 | # Learn more at https://jupyterbook.org/customize/toc.html 3 | 4 | format: jb-book 5 | root: Tutorial 0 - Overview 6 | chapters: 7 | - file: Tutorial 1 - TMY Weather Data 8 | - file: Tutorial 2 - POA Irradiance 9 | - file: Tutorial 3 - Module Temperature 10 | - file: Tutorial 4 - Model a Module's Performance 11 | - file: Tutorial 5 - Array Power 12 | - file: Tutorial A - Single Diode Model 13 | - file: Tutorial B - pvfree 14 | -------------------------------------------------------------------------------- /images/pvfree_table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/pvfree_table.png -------------------------------------------------------------------------------- /images/t1_DHI.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t1_DHI.PNG -------------------------------------------------------------------------------- /images/t1_DNI.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t1_DNI.PNG -------------------------------------------------------------------------------- /images/t1_GHI.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t1_GHI.PNG -------------------------------------------------------------------------------- /images/t2_POA.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t2_POA.PNG -------------------------------------------------------------------------------- /images/t2_solarpanel_directions.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t2_solarpanel_directions.PNG -------------------------------------------------------------------------------- /images/t4_PANOverview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t4_PANOverview.PNG -------------------------------------------------------------------------------- /images/t4_PVEducation_IVCurve.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t4_PVEducation_IVCurve.PNG -------------------------------------------------------------------------------- /images/t4_SingleDiodeEquation.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t4_SingleDiodeEquation.PNG -------------------------------------------------------------------------------- /images/t4_SingleDiodeParameterBehavior_to_TemperatureandIrradiance.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/t4_SingleDiodeParameterBehavior_to_TemperatureandIrradiance.PNG -------------------------------------------------------------------------------- /images/tracker-animation-backtrack-compressed.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tracker-animation-backtrack-compressed.gif -------------------------------------------------------------------------------- /images/tracker-animation-truetrack-compressed.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tracker-animation-truetrack-compressed.gif -------------------------------------------------------------------------------- /images/tutorial_0_kevin.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_0_kevin.PNG -------------------------------------------------------------------------------- /images/tutorial_0_mark.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_0_mark.PNG -------------------------------------------------------------------------------- /images/tutorial_0_silvana.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_0_silvana.PNG -------------------------------------------------------------------------------- /images/tutorial_1_DNIDHIGHI.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_DNIDHIGHI.PNG -------------------------------------------------------------------------------- /images/tutorial_1_NREL_DNI_Insolationmap_Year.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_NREL_DNI_Insolationmap_Year.PNG -------------------------------------------------------------------------------- /images/tutorial_1_NREL_GHI_Insolationmap_June.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_NREL_GHI_Insolationmap_June.PNG -------------------------------------------------------------------------------- /images/tutorial_1_NREL_GHI_Insolationmap_Year.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_NREL_GHI_Insolationmap_Year.PNG -------------------------------------------------------------------------------- /images/tutorial_1_NSRDB_example.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_NSRDB_example.PNG -------------------------------------------------------------------------------- /images/tutorial_1_SRRL.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_SRRL.PNG -------------------------------------------------------------------------------- /images/tutorial_1_overview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_overview.PNG -------------------------------------------------------------------------------- /images/tutorial_1_tmy3_example.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_1_tmy3_example.PNG -------------------------------------------------------------------------------- /images/tutorial_2_overview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_2_overview.PNG -------------------------------------------------------------------------------- /images/tutorial_3_overview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_3_overview.PNG -------------------------------------------------------------------------------- /images/tutorial_4_overview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_4_overview.PNG -------------------------------------------------------------------------------- /images/tutorial_banner.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_banner.PNG -------------------------------------------------------------------------------- /images/tutorial_overview.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PV-Tutorials/PVSC48-Python-Tutorial/a38f944c506dc311049392fecfa49539d297275d/images/tutorial_overview.PNG -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | matplotlib==3.3.4 2 | numpy==1.19.2 3 | pandas==1.2.3 4 | pvlib==0.8.1 --------------------------------------------------------------------------------