docs/tutorials/1 - Fixed Tilt Yearly Results.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working on a  Windows 10\n",
      "Python version  3.9.13 (main, Aug 25 2022, 23:51:50) [MSC v.1916 64 bit (AMD64)]\n",
      "Pandas version  1.5.3\n",
      "bifacial_radiance version  0.4.4.dev\n"
     ]
    }
   ],
   "source": [
    "# This information helps with debugging and getting support :)\n",
    "import sys, platform\n",
    "import pandas as pd\n",
    "import bifacial_radiance as br\n",
    "print(\"Working on a \", platform.system(), platform.release())\n",
    "print(\"Python version \", sys.version)\n",
    "print(\"Pandas version \", pd.__version__)\n",
    "print(\"bifacial_radiance version \", br.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 - Fixed-Tilt Yearly Results\n",
    "\n",
    "This jupyter journal will walk us through the creation of the most basic fixed-tilt simulation possible with bifacial_radiance.\n",
    "We will simulate a 1-up landscape system over a white rooftop.\n",
    "\n",
    "Steps include:\n",
    "\n",
    "<ol>\n",
    "    <li> <a href='#step1'> Create a folder for your simulation, and Load bifacial_radiance </a></li> \n",
    "    <li> <a href='#step2'> Create a Radiance Object </a></li> \n",
    "    <li> <a href='#step3'> Set the Albedo </a></li> \n",
    "    <li> <a href='#step4'> Download Weather Files </a></li> \n",
    "    <li> <a href='#step5'> Generate the Sky </a></li> \n",
    "    <li> <a href='#step6'> Define a Module type </a></li> \n",
    "    <li> <a href='#step7'> Create the scene </a></li> \n",
    "    <li> <a href='#step8'> Combine Ground, Sky and Scene Objects </a></li> \n",
    "    <li> <a href='#step9'> Analyze and get results </a></li> \n",
    "    <li> <a href='#step10'> Visualize scene options </a></li>   \n",
    "</ol>\n",
    "\n",
    "\n",
    "This jupyter journal will walk us through the creation of the most basic fixed-tilt simulation possible with bifacial_radiance.\n",
    "We will simulate a 1-up landscape system over a white rooftop.\n",
    "\n",
    "Steps include:\n",
    "\n",
    "<ol>\n",
    "    <li> <a href='#step1'> Create a folder for your simulation, and Load bifacial_radiance </a></li> \n",
    "    <li> <a href='#step2'> Create a Radiance Object </a></li> \n",
    "    <li> <a href='#step3'> Set the Albedo </a></li> \n",
    "    <li> <a href='#step4'> Download Weather Files </a></li> \n",
    "    <li> <a href='#step5'> Generate the Sky </a></li> \n",
    "    <li> <a href='#step6'> Define a Module type </a></li> \n",
    "    <li> <a href='#step7'> Create the scene </a></li> \n",
    "    <li> <a href='#step8'> Combine Ground, Sky and Scene Objects </a></li> \n",
    "    <li> <a href='#step9'> Analyze and get results </a></li> \n",
    "    <li> <a href='#step10'> Visualize scene options </a></li>   \n",
    "</ol>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 1. Create a folder for your simulation, and load bifacial_radiance \n",
    "\n",
    "First let's set the folder where the simulation will be saved. By default, this is the TEMP folder in the bifacial_radiance distribution.\n",
    "\n",
    "The lines below find the location of the folder relative to this Jupyter Journa. You can alternatively point to an empty directory (it will open a load GUI Visual Interface) or specify any other directory in your computer, for example:\n",
    "\n",
    "***testfolder = r'C:\\Users\\sayala\\Documents\\RadianceScenes\\Tutorials\\Journal1'***\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your simulation will be stored in C:\\Users\\cdeline\\Documents\\Python Scripts\\Bifacial_Radiance\\bifacial_radiance\\TEMP\\Tutorial_01\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "\n",
    "testfolder = Path().resolve().parent.parent / 'bifacial_radiance' / 'TEMP' / 'Tutorial_01'\n",
    "\n",
    "# Another option using relative address; for some operative systems you might need '/' instead of '\\'\n",
    "# testfolder = os.path.abspath(r'..\\..\\bifacial_radiance\\TEMP')  \n",
    "\n",
    "print (\"Your simulation will be stored in %s\" % testfolder)\n",
    "\n",
    "if not os.path.exists(testfolder):\n",
    "    os.makedirs(testfolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will load bifacial_radiance and other libraries from python that will be useful for this Jupyter Journal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from bifacial_radiance import *\n",
    "except ImportError:\n",
    "    raise RuntimeError('bifacial_radiance is required. download distribution')\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step2'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Create a Radiance Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "path = C:\\Users\\cdeline\\Documents\\Python Scripts\\Bifacial_Radiance\\bifacial_radiance\\TEMP\\Tutorial_01\n"
     ]
    }
   ],
   "source": [
    "# Create a RadianceObj 'object' named bifacial_example. no whitespace allowed\n",
    "demo = RadianceObj('tutorial_1',str(testfolder))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will create all the folder structure of the bifacial_radiance Scene in the designated testfolder in your computer, and it should look like this:\n",
    "\n",
    "\n",
    "![Folder Structure](../images_wiki/Journal1Pics/folderStructure.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step3'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Set the Albedo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see more options of ground materials available (located on ground.rad), run this function without any input. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Input albedo 0-1, or string from ground.printGroundMaterials().\n",
      "Alternatively, run setGround after readWeatherData()and setGround will read metdata.albedo if available\n"
     ]
    }
   ],
   "source": [
    "# Input albedo number or material name like 'concrete'.  \n",
    "demo.setGround()  # This prints available materials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a number between 0 and 1 is passed, it assumes it's an albedo value. For this example, we want a high-reflectivity rooftop albedo surface, so we will set the albedo to 0.62"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading albedo, 1 value(s), 0.620 avg\n",
      "1 nonzero albedo values.\n"
     ]
    }
   ],
   "source": [
    "albedo = 0.62\n",
    "demo.setGround(albedo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step4'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Download and Load Weather Files\n",
    "\n",
    "There are various options provided in bifacial_radiance to load weatherfiles. getEPW is useful because you just set the latitude and longitude of the location and it donwloads the meteorologicla data for any location. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting weather file: USA_VA_Richmond.724010_TMY2.epw\n",
      " ... OK!\n"
     ]
    }
   ],
   "source": [
    "# Pull in meteorological data using pyEPW for any global lat/lon\n",
    "epwfile = demo.getEPW(lat = 37.5, lon = -77.6)  # This location corresponds to Richmond, VA."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The downloaded EPW will be in the EPWs folder.\n",
    "\n",
    "To load the data, use readWeatherFile. This reads EPWs, TMY meterological data, or even your own data as long as it follows TMY data format (With any time resoultion)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8760 line in WeatherFile. Assuming this is a standard hourly WeatherFile for the year for purposes of saving Gencumulativesky temporary weather files in EPW folder.\n",
      "Coercing year to 2001\n",
      "Saving file EPWs\\metdata_temp.csv, # points: 8760\n",
      "Calculating Sun position for Metdata that is right-labeled  with a delta of -30 mins. i.e. 12 is 11:30 sunpos\n"
     ]
    }
   ],
   "source": [
    "# Read in the weather data pulled in above. \n",
    "metdata = demo.readWeatherFile(epwfile, coerce_year=2001) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step5'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Generate the Sky.\n",
    "\n",
    "Sky definitions can either be for a single time point with gendaylit function,\n",
    "or using gencumulativesky to generate a cumulativesky for the entire year.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded  EPWs\\metdata_temp.csv\n",
      "message: Error!  Solar altitude is -7 < -6 degrees and Idh = 13 > 10 W/m^2 on day 76 !Ibn is 0.  Attempting to continue!\n",
      "Error!  Solar altitude is -7 < -6 degrees and Idh = 11 > 10 W/m^2 on day 78 !Ibn is 0.  Attempting to continue!\n",
      "Error!  Solar altitude is -6 < -6 degrees and Idh = 14 > 10 W/m^2 on day 81 !Ibn is 0.  Attempting to continue!\n",
      "There were 4537 sun up hours in this climate file\n",
      "Total Ibh/Lbh: 0.000000\n"
     ]
    }
   ],
   "source": [
    "fullYear = True\n",
    "if fullYear:\n",
    "    demo.genCumSky() # entire year.\n",
    "else:\n",
    "    timeindex = metdata.datetime.index(pd.to_datetime('2001-06-17 12:0:0 -7'))\n",
    "    demo.gendaylit(timeindex)  # Noon, June 17th (timepoint # 4020)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method gencumSky calculates the hourly radiance of the sky hemisphere by dividing it into 145 patches. Then it adds those hourly values to generate one single <b> cumulative sky</b>. Here is a visualization of this patched hemisphere for Richmond, VA, US. Can you deduce from the radiance values of each patch which way is North?\n",
    "\n",
    "![Example of the hemisphere cumulative sky](../images_wiki/Journal1Pics/cumulativesky.png)\n",
    "\n",
    "Answer: Since Richmond is in the Northern Hemisphere, the modules face the south, which is where most of the radiation from the sun is coming. The north in this picture is the darker blue areas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step6'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. DEFINE a Module type\n",
    "\n",
    "You can create a custom PV module type. In this case we are defining a module named \"test-module\", in landscape. The x value defines the size of the module along the row, so for landscape modules x > y. This module measures y = 0.984 x = 1.695. \n",
    "\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "Modules in this example are 100% opaque. For drawing each cell, makeModule needs more inputs with cellLevelModule = True. You can also specify a lot more variables in makeModule like multiple modules, torque tubes, spacing between modules, etc. Reffer to the <a href=\"https://bifacial-radiance.readthedocs.io/en/latest/generated/bifacial_radiance.RadianceObj.makeModule.html#bifacial_radiance.RadianceObj.makeModule\"> Module Documentation </a> and read the following jupyter journals to explore all your options.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Module Name: test-module\n",
      "Module test-module updated in module.json\n",
      "Pre-existing .rad file objects\\test-module.rad will be overwritten\n",
      "\n",
      "<class 'bifacial_radiance.module.ModuleObj'> : {'x': 1.695, 'y': 0.984, 'z': 0.02, 'modulematerial': 'black', 'scenex': 1.705, 'sceney': 0.984, 'scenez': 0.1, 'numpanels': 1, 'bifi': 1, 'text': '! genbox black test-module 1.695 0.984 0.02 | xform -t -0.8475 -0.492 0 -a 1 -t 0 0.984 0', 'modulefile': 'objects\\\\test-module.rad', 'glass': False, 'glassEdge': 0.01, 'offsetfromaxis': 0, 'xgap': 0.01, 'ygap': 0.0, 'zgap': 0.1}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "module_type = 'test-module' \n",
    "module = demo.makeModule(name=module_type,x=1.695, y=0.984)\n",
    "print(module)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you want to use a pre-defined module or a module you've created previously, they are stored in a JSON format in data/module.json, and the options available can be called with printModules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available module names: ['PrismSolar-Bi60', 'basic-module', 'test-module']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "availableModules = demo.printModules()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step7'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Make the Scene\n",
    "\n",
    " The sceneDicitonary specifies the information of the scene, such as number of rows, number of modules per row, azimuth, tilt, clearance_height (distance between the ground and lowest point of the module) and any other parameter. \n",
    " \n",
    " Azimuth gets measured from N = 0, so for South facing modules azimuth should equal 180 degrees\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "sceneDict = {'tilt':10,'pitch':3,'clearance_height':0.2,'azimuth':180, 'nMods': 20, 'nRows': 7} \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make the scene we have to create a Scene Object through the method makeScene. This method will create a .rad file in the objects folder, with the parameters specified in sceneDict and the module created above.  You can alternatively pass a string with the name of the `moduletype`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "scene = demo.makeScene(module,sceneDict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step8'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. COMBINE the Ground, Sky, and the Scene Objects\n",
    "\n",
    "Radiance requires an \"Oct\" file that combines the ground, sky and the scene object into it. \n",
    "The method makeOct does this for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created tutorial_1.oct\n"
     ]
    }
   ],
   "source": [
    "\n",
    "octfile = demo.makeOct(demo.getfilelist())  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see what files got merged into the octfile, you can use the helper method getfilelist. This is useful for advanced simulations too, specially when you want to have different Scene objects in the same simulation, or if you want to add other custom elements to your scene (like a building, for example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['materials\\\\ground.rad',\n",
       " 'skies\\\\cumulative.rad',\n",
       " 'objects\\\\test-module_C_0.20_rtr_3.00_tilt_10_20modsx7rows_origin0,0.rad']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "demo.getfilelist()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step9'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. ANALYZE and get Results\n",
    "\n",
    "Once the octfile tying the scene, ground and sky has been created, we create an Analysis Object. We first have to create an Analysis object, and then we have to specify where the sensors will be located with moduleAnalysis. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's create the Analysis Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "analysis = AnalysisObj(octfile, demo.basename)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then let's specify the sensor location. If no parameters are passed to moduleAnalysis, it will scan the center module of the center row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "frontscan, backscan = analysis.moduleAnalysis(scene)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The frontscan and backscan include a linescan along a chord of the module, both on the front and back. \n",
    "\n",
    "![Simple example for south facing module](../images_wiki/Journal1Pics/frontscan_backscan.png)\n",
    "Analysis saves the measured irradiances in the front and in the back on the results folder.  Prints out the ratio of the average of the rear and front irradiance values along a chord of the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linescan in process: tutorial_1_Front\n",
      "Linescan in process: tutorial_1_Back\n",
      "Saved: results\\irr_tutorial_1.csv\n"
     ]
    }
   ],
   "source": [
    "\n",
    "results = analysis.analysis(octfile, demo.basename, frontscan, backscan)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are also automatically saved in the results folder. Some of our input/output functions can be used to read the results and work with them, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>rearZ</th>\n",
       "      <th>mattype</th>\n",
       "      <th>rearMat</th>\n",
       "      <th>Wm2Front</th>\n",
       "      <th>Wm2Back</th>\n",
       "      <th>Back/FrontRatio</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.391</td>\n",
       "      <td>0.238</td>\n",
       "      <td>0.216</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1630394.0</td>\n",
       "      <td>435239.3</td>\n",
       "      <td>0.267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.294</td>\n",
       "      <td>0.255</td>\n",
       "      <td>0.233</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1630987.0</td>\n",
       "      <td>330362.8</td>\n",
       "      <td>0.203</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.197</td>\n",
       "      <td>0.272</td>\n",
       "      <td>0.250</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1631598.0</td>\n",
       "      <td>260892.0</td>\n",
       "      <td>0.160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.101</td>\n",
       "      <td>0.289</td>\n",
       "      <td>0.267</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1632208.0</td>\n",
       "      <td>218605.1</td>\n",
       "      <td>0.134</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.004</td>\n",
       "      <td>0.306</td>\n",
       "      <td>0.284</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1632819.0</td>\n",
       "      <td>206471.0</td>\n",
       "      <td>0.126</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>-0.0</td>\n",
       "      <td>0.093</td>\n",
       "      <td>0.323</td>\n",
       "      <td>0.302</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1633430.0</td>\n",
       "      <td>212833.6</td>\n",
       "      <td>0.130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>-0.0</td>\n",
       "      <td>0.190</td>\n",
       "      <td>0.340</td>\n",
       "      <td>0.319</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1634041.0</td>\n",
       "      <td>233727.4</td>\n",
       "      <td>0.143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>-0.0</td>\n",
       "      <td>0.287</td>\n",
       "      <td>0.357</td>\n",
       "      <td>0.336</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1635704.0</td>\n",
       "      <td>277579.4</td>\n",
       "      <td>0.170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>-0.0</td>\n",
       "      <td>0.384</td>\n",
       "      <td>0.374</td>\n",
       "      <td>0.353</td>\n",
       "      <td>a9.3.a0.test-module.6457</td>\n",
       "      <td>a9.3.a0.test-module.2310</td>\n",
       "      <td>1635450.0</td>\n",
       "      <td>327750.6</td>\n",
       "      <td>0.200</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     x      y      z  rearZ                   mattype  \\\n",
       "0  0.0 -0.391  0.238  0.216  a9.3.a0.test-module.6457   \n",
       "1  0.0 -0.294  0.255  0.233  a9.3.a0.test-module.6457   \n",
       "2  0.0 -0.197  0.272  0.250  a9.3.a0.test-module.6457   \n",
       "3  0.0 -0.101  0.289  0.267  a9.3.a0.test-module.6457   \n",
       "4  0.0 -0.004  0.306  0.284  a9.3.a0.test-module.6457   \n",
       "5 -0.0  0.093  0.323  0.302  a9.3.a0.test-module.6457   \n",
       "6 -0.0  0.190  0.340  0.319  a9.3.a0.test-module.6457   \n",
       "7 -0.0  0.287  0.357  0.336  a9.3.a0.test-module.6457   \n",
       "8 -0.0  0.384  0.374  0.353  a9.3.a0.test-module.6457   \n",
       "\n",
       "                    rearMat   Wm2Front   Wm2Back  Back/FrontRatio  \n",
       "0  a9.3.a0.test-module.2310  1630394.0  435239.3            0.267  \n",
       "1  a9.3.a0.test-module.2310  1630987.0  330362.8            0.203  \n",
       "2  a9.3.a0.test-module.2310  1631598.0  260892.0            0.160  \n",
       "3  a9.3.a0.test-module.2310  1632208.0  218605.1            0.134  \n",
       "4  a9.3.a0.test-module.2310  1632819.0  206471.0            0.126  \n",
       "5  a9.3.a0.test-module.2310  1633430.0  212833.6            0.130  \n",
       "6  a9.3.a0.test-module.2310  1634041.0  233727.4            0.143  \n",
       "7  a9.3.a0.test-module.2310  1635704.0  277579.4            0.170  \n",
       "8  a9.3.a0.test-module.2310  1635450.0  327750.6            0.200  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "load.read1Result('results\\irr_tutorial_1.csv')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen in the results for the *Wm2Front* and *WM2Back*, the irradiance values are quite high. This is because a cumulative sky simulation was performed on <b> step 5 </b>, so this is the total irradiance over all the hours of the year that the module at each sampling point will receive. Dividing the back irradiance average by the front irradiance average will give us the bifacial gain for the year:\n",
    "\n",
    "![Bifacial Gain in Irradiance Formula](../images_wiki/Journal1Pics/BGG_Formula.PNG)\n",
    "\n",
    "Assuming that our module has a bifaciality factor (rear to front performance) of 90%, our <u> bifacial gain </u> is of:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Annual bifacial ratio: 0.15 \n"
     ]
    }
   ],
   "source": [
    "\n",
    "bifacialityfactor = 0.9\n",
    "print('Annual bifacial ratio: %0.2f ' %( np.mean(analysis.Wm2Back) * bifacialityfactor / np.mean(analysis.Wm2Front)) )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step10'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. View / Render the Scene\n",
    "\n",
    "If you used gencumsky or gendaylit, you can view the <b> Scene </b> by navigating on a command line to the folder and typing:\n",
    "\n",
    "***objview materials\\ground.rad objects\\test-module_C_0.20000_rtr_3.00000_tilt_10.00000_20modsx7rows_origin0,0.rad***\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "## Comment the ! line below to run rvu from the Jupyter notebook instead of your terminal.\n",
    "## Simulation will stop until you close the rvu window\n",
    "\n",
    "# !objview materials\\ground.rad objects\\test-module_C_0.20000_rtr_3.00000_tilt_10.00000_20modsx7rows_origin0,0.rad\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This <b> objview </b> has 3 different light sources of its own, so the shading is not representative.\n",
    "\n",
    "ONLY If you used <b> gendaylit </b>, you can view the scene correctly illuminated with the sky you generated after generating the oct file, with \n",
    "\n",
    "***rvu -vf views\\front.vp -e .01 tutorial_1.oct***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "## Comment the line below to run rvu from the Jupyter notebook instead of your terminal.\n",
    "## Simulation will stop until you close the rvu window\n",
    "\n",
    "#!rvu -vf views\\front.vp -e .01 tutorial_1.oct\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The <b> rvu </b> manual can be found here: manual page here: http://radsite.lbl.gov/radiance/rvu.1.html\n",
    "\n",
    "Or you can also use the code below from bifacial_radiance to generate an HDR rendered image of the scene. You can choose from front view or side view in the views folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scene image saved: images/Scene0_side.hdr\n",
      "Generating visible render of scene\n",
      "Generating scene in WM-2. This may take some time.\n",
      "Saving scene in false color\n"
     ]
    }
   ],
   "source": [
    "# Print a default image of the module and scene that is saved in /images/ folder. (new in v0.4.2)\n",
    "scene.saveImage()\n",
    "\n",
    "# Make a color render and falsecolor image of the scene.\n",
    "analysis.makeImage('side.vp')\n",
    "analysis.makeFalseColor('side.vp')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how the False Color image stored in images folder should look like:\n",
    "\n",
    "![OpenHDR image example of False color](../images_wiki/Journal1Pics/openhdr_FalseColorExample.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Files are saved as .hdr (high definition render) files.  Try LuminanceHDR viewer (free) to view them, or https://viewer.openhdr.org/ \n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}