docs/tutorials/4 - Medium Level Example - Debugging your Scene with Custom Objects (Fixed Tilt 2-up with Torque Tube + CLEAN Routine + CustomObject).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 - Medium Level Example - Debugging your Scene with Custom Objects\n",
    "### Fixed Tilt 2-up with Torque Tube + CLEAN Routine + CustomObject\n",
    "\n",
    "This journal has examples of various things, some which hav ebeen covered before and some in more depth:\n",
    "\n",
    "<ul>\n",
    "    <li> Running a fixed_tilt simulation beginning to end.  </li>\n",
    "    <li> Creating a 2-up module with torque-tube, and detailed geometry of spacings in xgap, ygap and zgap.  </li>\n",
    "    <li> Calculating the tracker angle for a specific time, in case you want to use that value to model a fixed_tilt setup.  </li>\n",
    "    <li> Loading and cleaning results, particularly important when using setups with torquetubes / ygaps.  </li>\n",
    "    <li> Adding a \"Custom Object\" or **marker** at the Origin of the Scene, to do a visual sanity-check of the geometry. </li>\n",
    "</ul>\n",
    "\n",
    "It will look something like this (without the marker in this visualization):\n",
    "\n",
    "![What we are trying to re-create](../images_wiki/Journal_example_torquetube.PNG)\n",
    "\n",
    "### STEPS:\n",
    "\n",
    "<ol type='1'>\n",
    "    <li> <a href='#step1'> Specify Working Folder and Import Program </a></li>\n",
    "    <li> <a href='#step2'> Specify all variables </a></li>\n",
    "    <li> <a href='#step3'> Create the Radiance Object and generate the Sky </a></li>\n",
    "    <li> <a href='#step4'> Calculating tracker angle/geometry for a specific timestamp </a></li>\n",
    "    <li> <a href='#step5'> Making the Module & the Scene,  Visualize and run Analysis </a></li>\n",
    "    <li> <a href='#step6'> Calculate Bifacial Ratio (clean results) </a></li>\n",
    "    <li> <a href='#step7'> Add Custom Elements to your Scene Example: Marker at 0,0 position </a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step1'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Specify Working Folder and Import Program\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your simulation will be stored in C:\\Users\\sayala\\Documents\\GitHub\\bifacial_radiance\\bifacial_radiance\\TEMP\\Tutorial_04\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "\n",
    "testfolder = Path().resolve().parent.parent / 'bifacial_radiance' / 'TEMP' / 'Tutorial_04'\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)\n",
    "\n",
    "import bifacial_radiance\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step2'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Specify all variables for the module and scene\n",
    "\n",
    "Below find a list of all of the possible parameters for makeModule. \n",
    "scene and simulation parameters are also organized below. \n",
    "This simulation will be a complete simulation in terms of parameters that you can modify.\n",
    "\n",
    "The below routine creates a HEXAGONAL torque tube, for a 2-UP configuration of a specific module size. Parameters for the module, the torque tube, and the scene are below.\n",
    "This is being run with gendaylit, for one specific timestamp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulationname = 'tutorial_4'\n",
    "\n",
    "## SceneDict Parameters\n",
    "gcr = 0.33   # ground cover ratio,  = module_height / pitch\n",
    "albedo = 0.28  #'concrete'     # ground albedo\n",
    "hub_height = 2.35  # we could also pass clearance_height.   \n",
    "azimuth_ang = 90 # Modules will be facing East.\n",
    "lat = 37.5\n",
    "lon = -77.6\n",
    "nMods = 4   # doing a smaller array for better visualization on this example.\n",
    "nRows = 2  \n",
    "\n",
    "# MakeModule Parameters\n",
    "module_type='test-module'\n",
    "x = 1.996      # landscape, sinze x > y. Remember that orientation has been deprecated.\n",
    "y = 0.991\n",
    "tilt = 10\n",
    "numpanels = 2  # doing a 2-up system!\n",
    "\n",
    "\n",
    "# Gaps:\n",
    "xgap = 0.05  # distance between modules in the row.\n",
    "ygap = 0.15  # distance between the 2 modules along the collector slope.\n",
    "zgap = 0.175 # if there is a torquetube, this is the distance between the torquetube and the modules.\n",
    "# If there is not a module, zgap is the distance between the module and the axis of rotation (relevant for \n",
    "# tracking systems. \n",
    "\n",
    "# TorqueTube Parameters\n",
    "tubetype = 'Hex'\n",
    "diameter = 0.15\n",
    "material = 'Metal_Grey'       # IT's NOT GRAY, IT's GREY.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step3'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Create the Radiance Object and generate the Sky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "path = C:\\Users\\sayala\\Documents\\GitHub\\bifacial_radiance\\bifacial_radiance\\TEMP\\Tutorial_04\n",
      "Loading albedo, 1 value(s), 0.280 avg\n",
      "1 nonzero albedo values.\n",
      "Getting weather file: USA_VA_Richmond.724010_TMY2.epw\n",
      " ... OK!\n",
      "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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'skies\\\\sky2_37.5_-77.33_2001-06-17_1300.rad'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "demo = bifacial_radiance.RadianceObj(simulationname, path=str(testfolder))  # Create a RadianceObj 'object'\n",
    "demo.setGround(albedo) # input albedo number or material name like 'concrete'.  To see options, run this without any input.\n",
    "epwfile = demo.getEPW(lat,lon) # pull TMY data for any global lat/lon\n",
    "metdata = demo.readWeatherFile(epwfile, coerce_year=2001) # read in the EPW weather data from above\n",
    "\n",
    "timestamp = metdata.datetime.index(pd.to_datetime('2001-06-17 13:0:0 -5')) # Make this timezone aware, use -5 for EST.\n",
    "demo.gendaylit(timestamp)  # Mid-day, June 17th"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step4'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Calculating tracker angle/geometry for a specific timestamp\n",
    "\n",
    "This trick is useful if you are trying to use the fixed-tilt steps in bifacial_radiance to model a tracker for one specific point in time (if you take a picture of a tracker, it looks fixed, right? Well then). \n",
    "\n",
    "We assigned a 10 degree tilt at the beginning, but if we were to model a tracker as a fixed-tilt element because we are interested in only one point in time, this routine will tell us what tilt to use. *Please note that to model a tracker as fixed tilt, we suggest passing a hub_height, otherwise you will have to calculate the clearance_height manually.*\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "Details: you might have noticed in the previoust tutorial looking at the tracker dictionary, but the way that bifacial_radiance handles tracking: If the tracker is N-S axis azimuth, the surface azimuth of the modules will be set to 90 always, with a tilt that is either positive (for the early morning, facing East), or negative (for the afternoon, facing west).\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " NEW Calculated Tilt: -4.67 \n"
     ]
    }
   ],
   "source": [
    "# Some tracking parameters that won't be needed after getting this angle:\n",
    "axis_azimuth = 180\n",
    "axis_tilt = 0\n",
    "limit_angle = 60\n",
    "backtrack = True\n",
    "tilt = demo.getSingleTimestampTrackerAngle(metdata, timestamp, gcr, axis_azimuth, axis_tilt,limit_angle, backtrack)\n",
    "\n",
    "print (\"\\n NEW Calculated Tilt: %s \" % tilt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step5'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Making the Module & the Scene, Visualize and run Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Module Name: test-module\n",
      "Module test-module updated in module.json\n",
      "Module test-module updated in module.json\n",
      "Pre-existing .rad file objects\\test-module.rad will be overwritten\n",
      "Created tutorial_4.oct\n"
     ]
    }
   ],
   "source": [
    "# Making module with all the variables\n",
    "module = demo.makeModule(name=module_type,x=x,y=y,bifi=1, \n",
    "                         zgap=zgap, ygap=ygap,  xgap=xgap, numpanels=numpanels)\n",
    "module.addTorquetube(diameter=diameter, material=material, tubetype=tubetype,\n",
    "                    visible=True, axisofrotation=True)\n",
    "\n",
    "# create a scene with all the variables. \n",
    "# Specifying the pitch automatically with the collector width (sceney) returned by the module object.\n",
    "# Height has been deprecated as an input. pass clearance_height or hub_height in the scenedict.\n",
    "\n",
    "sceneDict = {'tilt':tilt,'pitch': np.round(module.sceney / gcr,3),\n",
    "             'hub_height':hub_height,'azimuth':azimuth_ang, \n",
    "             'module_type':module_type, 'nMods': nMods, 'nRows': nRows}  \n",
    "\n",
    "scene = demo.makeScene(module=module, sceneDict=sceneDict) #makeScene creates a .rad file of the Scene\n",
    "\n",
    "octfile = demo.makeOct(demo.getfilelist())  # makeOct combines all of the ground, sky and object files into a .oct file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point you should be able to go into a command window (cmd.exe) and check the geometry. It should look like the image at the beginning of the journal. Example:\n",
    "    \n",
    "#### rvu -vf views\\front.vp -e .01 -pe 0.02 -vp -2 -12 14.5 tutorial_4.oct\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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_4.oct\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then proceed happily with your analysis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linescan in process: tutorial_4_Front\n",
      "Linescan in process: tutorial_4_Back\n",
      "Saved: results\\irr_tutorial_4.csv\n"
     ]
    }
   ],
   "source": [
    "analysis = bifacial_radiance.AnalysisObj(octfile, demo.name)  # return an analysis object including the scan dimensions for back irradiance\n",
    "\n",
    "sensorsy = 200 # setting this very high to see a detailed profile of the irradiance, including\n",
    "#the shadow of the torque tube on the rear side of the module.\n",
    "frontscan, backscan = analysis.moduleAnalysis(scene, modWanted = 2, rowWanted = 1, sensorsy = 200)\n",
    "frontDict, backDict = analysis.analysis(octfile, demo.name, frontscan, backscan)  # compare the back vs front irradiance  \n",
    "\n",
    "# print('\"Annual\" bifacial ratio average:  %0.3f' %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) ) )\n",
    "# See comment below of why this line is commented out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step6'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 6. Calculate Bifacial Ratio (clean results)\n",
    "\n",
    "Although we could calculate a bifacial ratio average at this point, this value would be misleading, since some of the sensors generated will fall on the torque tube, the sky, and/or the ground since we have torquetube and ygap in the scene. To calculate the real bifacial ratio average, we must use the clean routines.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing the dataframe containing the results just calculated in results/irr_tutorial_4.csv: \n"
     ]
    },
    {
     "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>1.029825</td>\n",
       "      <td>6.305862e-17</td>\n",
       "      <td>2.706027</td>\n",
       "      <td>2.684100</td>\n",
       "      <td>a1.0.a0.test-module.6457</td>\n",
       "      <td>a1.0.a0.test-module.2310</td>\n",
       "      <td>910.402000</td>\n",
       "      <td>189.224967</td>\n",
       "      <td>0.207847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.019254</td>\n",
       "      <td>6.241128e-17</td>\n",
       "      <td>2.705163</td>\n",
       "      <td>2.683236</td>\n",
       "      <td>a1.0.a0.test-module.6457</td>\n",
       "      <td>a1.0.a0.test-module.2310</td>\n",
       "      <td>910.404333</td>\n",
       "      <td>189.023133</td>\n",
       "      <td>0.207625</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.008682</td>\n",
       "      <td>6.176395e-17</td>\n",
       "      <td>2.704300</td>\n",
       "      <td>2.682373</td>\n",
       "      <td>a1.0.a0.test-module.6457</td>\n",
       "      <td>a1.0.a0.test-module.2310</td>\n",
       "      <td>910.404500</td>\n",
       "      <td>188.821633</td>\n",
       "      <td>0.207404</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.998110</td>\n",
       "      <td>6.111662e-17</td>\n",
       "      <td>2.703436</td>\n",
       "      <td>2.681509</td>\n",
       "      <td>a1.0.a0.test-module.6457</td>\n",
       "      <td>a1.0.a0.test-module.2310</td>\n",
       "      <td>910.404767</td>\n",
       "      <td>188.620133</td>\n",
       "      <td>0.207182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.987538</td>\n",
       "      <td>6.046929e-17</td>\n",
       "      <td>2.702573</td>\n",
       "      <td>2.680646</td>\n",
       "      <td>a1.0.a0.test-module.6457</td>\n",
       "      <td>a1.0.a0.test-module.2310</td>\n",
       "      <td>910.404967</td>\n",
       "      <td>188.418633</td>\n",
       "      <td>0.206961</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>195</th>\n",
       "      <td>-1.031666</td>\n",
       "      <td>-6.317134e-17</td>\n",
       "      <td>2.537628</td>\n",
       "      <td>2.515701</td>\n",
       "      <td>a1.0.a1.test-module.6457</td>\n",
       "      <td>a1.0.a1.test-module.2310</td>\n",
       "      <td>909.756967</td>\n",
       "      <td>185.710300</td>\n",
       "      <td>0.204132</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>-1.042238</td>\n",
       "      <td>-6.381867e-17</td>\n",
       "      <td>2.536764</td>\n",
       "      <td>2.514838</td>\n",
       "      <td>a1.0.a1.test-module.6457</td>\n",
       "      <td>a1.0.a1.test-module.2310</td>\n",
       "      <td>909.756833</td>\n",
       "      <td>185.904500</td>\n",
       "      <td>0.204345</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>-1.052810</td>\n",
       "      <td>-6.446600e-17</td>\n",
       "      <td>2.535901</td>\n",
       "      <td>2.513974</td>\n",
       "      <td>a1.0.a1.test-module.6457</td>\n",
       "      <td>a1.0.a1.test-module.2310</td>\n",
       "      <td>909.756667</td>\n",
       "      <td>186.098700</td>\n",
       "      <td>0.204559</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198</th>\n",
       "      <td>-1.063381</td>\n",
       "      <td>-6.511333e-17</td>\n",
       "      <td>2.535037</td>\n",
       "      <td>2.513110</td>\n",
       "      <td>a1.0.a1.test-module.6457</td>\n",
       "      <td>a1.0.a1.test-module.2310</td>\n",
       "      <td>909.756500</td>\n",
       "      <td>186.292900</td>\n",
       "      <td>0.204772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>199</th>\n",
       "      <td>-1.073953</td>\n",
       "      <td>-6.576067e-17</td>\n",
       "      <td>2.534174</td>\n",
       "      <td>2.512247</td>\n",
       "      <td>a1.0.a1.test-module.6457</td>\n",
       "      <td>a1.0.a1.test-module.2310</td>\n",
       "      <td>909.756333</td>\n",
       "      <td>186.487100</td>\n",
       "      <td>0.204986</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>200 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            x             y         z     rearZ                   mattype  \\\n",
       "0    1.029825  6.305862e-17  2.706027  2.684100  a1.0.a0.test-module.6457   \n",
       "1    1.019254  6.241128e-17  2.705163  2.683236  a1.0.a0.test-module.6457   \n",
       "2    1.008682  6.176395e-17  2.704300  2.682373  a1.0.a0.test-module.6457   \n",
       "3    0.998110  6.111662e-17  2.703436  2.681509  a1.0.a0.test-module.6457   \n",
       "4    0.987538  6.046929e-17  2.702573  2.680646  a1.0.a0.test-module.6457   \n",
       "..        ...           ...       ...       ...                       ...   \n",
       "195 -1.031666 -6.317134e-17  2.537628  2.515701  a1.0.a1.test-module.6457   \n",
       "196 -1.042238 -6.381867e-17  2.536764  2.514838  a1.0.a1.test-module.6457   \n",
       "197 -1.052810 -6.446600e-17  2.535901  2.513974  a1.0.a1.test-module.6457   \n",
       "198 -1.063381 -6.511333e-17  2.535037  2.513110  a1.0.a1.test-module.6457   \n",
       "199 -1.073953 -6.576067e-17  2.534174  2.512247  a1.0.a1.test-module.6457   \n",
       "\n",
       "                      rearMat    Wm2Front     Wm2Back  Back/FrontRatio  \n",
       "0    a1.0.a0.test-module.2310  910.402000  189.224967         0.207847  \n",
       "1    a1.0.a0.test-module.2310  910.404333  189.023133         0.207625  \n",
       "2    a1.0.a0.test-module.2310  910.404500  188.821633         0.207404  \n",
       "3    a1.0.a0.test-module.2310  910.404767  188.620133         0.207182  \n",
       "4    a1.0.a0.test-module.2310  910.404967  188.418633         0.206961  \n",
       "..                        ...         ...         ...              ...  \n",
       "195  a1.0.a1.test-module.2310  909.756967  185.710300         0.204132  \n",
       "196  a1.0.a1.test-module.2310  909.756833  185.904500         0.204345  \n",
       "197  a1.0.a1.test-module.2310  909.756667  186.098700         0.204559  \n",
       "198  a1.0.a1.test-module.2310  909.756500  186.292900         0.204772  \n",
       "199  a1.0.a1.test-module.2310  909.756333  186.487100         0.204986  \n",
       "\n",
       "[200 rows x 9 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultFile='results/irr_tutorial_4.csv'\n",
    "results_loaded = bifacial_radiance.load.read1Result(resultFile)\n",
    "print(\"Printing the dataframe containing the results just calculated in %s: \" % resultFile)\n",
    "results_loaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking at only 1 sensor in the middle -- position 100 out of the 200 sensors sampled:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "x                             -0.02735\n",
       "y                                 -0.0\n",
       "z                             2.619669\n",
       "rearZ                         2.597742\n",
       "mattype            a1.0.hextube1a.6457\n",
       "rearMat                            sky\n",
       "Wm2Front                    788.347433\n",
       "Wm2Back                       161.8852\n",
       "Back/FrontRatio               0.205347\n",
       "Name: 100, dtype: object"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Looking at only 1 sensor in the middle -- position 100 out of the 200 sensors sampled:\")\n",
    "results_loaded.loc[100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, we can see above that sensor 100 falls in the hextube, and in the sky. We need to remove this to calculate the real bifacial_gain from the irradiance falling into the modules. To do this we use cleanResult form the load.py module in bifacial_radiance. This finds the invalid materials and sets the irradiance values for those materials to NaN\n",
    "\n",
    "This might take some time in the current version. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cleaning Results:\n",
    "# remove invalid materials and sets the irradiance values to NaN\n",
    "clean_results = bifacial_radiance.load.cleanResult(results_loaded)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sampling the same location as before to see what the results are now:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "x                             -0.02735\n",
       "y                                 -0.0\n",
       "z                             2.619669\n",
       "rearZ                         2.597742\n",
       "mattype            a1.0.hextube1a.6457\n",
       "rearMat                            sky\n",
       "Wm2Front                           NaN\n",
       "Wm2Back                            NaN\n",
       "Back/FrontRatio               0.205347\n",
       "Name: 100, dtype: object"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Sampling the same location as before to see what the results are now:\")\n",
    "clean_results.loc[100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CORRECT Annual bifacial ratio average:  0.203\n",
      "\n",
      "(If we had not done the cleaning routine, the bifacial ratio would have been  calculated to 0.205  <-- THIS VALUE IS WRONG)\n"
     ]
    }
   ],
   "source": [
    "print('CORRECT Annual bifacial ratio average:  %0.3f' %( clean_results['Wm2Back'].sum() / clean_results['Wm2Front'].sum() ))\n",
    "\n",
    "print (\"\\n(If we had not done the cleaning routine, the bifacial ratio would have been \", \\\n",
    "      \"calculated to %0.3f  <-- THIS VALUE IS WRONG)\" %( sum(analysis.Wm2Back) / sum(analysis.Wm2Front) )) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='step7'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Add Custom Elements to your Scene Example: Marker at 0,0 position\n",
    "This shows how to add a custom element, in this case a Cube, that will be placed in the center of your already created scene to mark the 0,0 location. \n",
    "\n",
    "This can be added at any point after makeScene has been run once.  Notice that if this extra element is in the scene and the analysis sensors fall on this element, they will measure irradiance at this element and no the modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to create a \"MyMarker.rad\" file in the objects folder, right after we make the Module. \n",
    "This is a prism (so we use 'genbox'), that is black from the ground.rad list of materials ('black')\n",
    "We are naming it 'CenterMarker'\n",
    "Its sides are going to be 0.5x0.5x0.5 m \n",
    "and We are going to leave its bottom surface coincident with the plane z=0, but going to center on X and Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Custom Object Name objects\\MyMarker.rad\n"
     ]
    }
   ],
   "source": [
    "name='MyMarker'\n",
    "text='! genbox black CenterMarker 0.1 0.1 4 | xform -t -0.05 -0.05 0'\n",
    "customObject = demo.makeCustomObject(name,text)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This should have created a MyMarker.rad object on your objects folder.\n",
    "\n",
    "But creating the object does not automatically adds it to the seen. So let's now add the customObject to the Scene. We are not going to translate it or anything because we want it at the center, but you can pass translation, rotation, and any other XFORM command from Radiance.\n",
    "\n",
    "I am passing a rotation 0 because xform has to have something (I think) otherwise it gets confused."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created tutorial_4.oct\n"
     ]
    }
   ],
   "source": [
    "demo.appendtoScene(scene.radfiles, customObject, '!xform -rz 0')\n",
    "# makeOct combines all of the ground, sky and object files into a .oct file.\n",
    "octfile = demo.makeOct(demo.getfilelist())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "appendtoScene appended to the Scene.rad file the name of the custom object we created and the xform transformation we included as text. Then octfile merged this new scene with the ground and sky files.\n",
    "\n",
    "At this point you should be able to go into a command window (cmd.exe) and check the geometry, and the marker should be there. Example:\n",
    "    \n",
    "   #### rvu -vf views\\front.vp -e .01 tutorial_4.oct\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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_4.oct\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you ran the getTrackerAngle detour and appended the marker, it should look like this:\n",
    "\n",
    "\n",
    "![Marker position at 0,0](../images_wiki/Journal_example_marker_origin.PNG)\n",
    "\n",
    "If you do an analysis and any of the sensors hits the Box object we just created, the list of materials in the result.csv file should say something with \"CenterMarker\" on it. \n",
    "\n",
    "#### See more examples of the use of makeCustomObject and appendtoScene on the Bifacial Carport/Canopies Tutorial"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}