Merge branch 'release/2.1.3' into master

This release contains the high-level API LSC object.

This should make performing basic LSC simualtions straightforward.

Author: danieljfarrell

README.md

@@ -1,57 +1,86 @@
 ![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/docs/logo.png)
 
-> Optical ray tracing for luminescent materials and spectral converter photovoltaic devices 
+> Optical ray tracing for luminescent materials and spectral converter photovoltaic devices
 
-## Install
+# Ray-tracing luminescent solar concentrators
 
-    pip install pvtrace
+*pvtrace* is a statistical photon path tracer written in Python. Rays are followed through a 3D scene and their interactions with objects are recorded to build up statistical information about energy flow.
+
+This is useful in photovoltaics and non-imaging optics where the goal is to design systems which efficiently transport light to target locations. 
+
+One of its key features is the ability to simulate re-absorption in luminescent materials. For example, like in devices like Luminescent Solar Concentrators (LSCs).
+
+A basic LSC can be simulated and visualised in five lines of code,
+
+```python
+from pvtrace import *
+lsc = LSC((5.0, 5.0, 1.0))  # size in cm
+lsc.show()                  # open visualiser
+lsc.simulate(100)           # emit 100 rays
+lsc.report()                # print report
+```
+
+This script will render the ray-tracing in real time,
+
+![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/dev/lsc-device/docs/pvtrace-demo.gif)
+
+pvtrace has been validate against three other luminescent concentrator codes. For full details see [Validation.ipynb](https://github.com/danieljfarrell/pvtrace/blob/dev/lsc-device/examples/Validation.ipynb) notebook
+
+![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/dev/lsc-device/examples/Validation.png)
 
-Tutorials are in Jupyter notebook form so to view those
+# Install
 
-    pip install jupyter
+## MacOS using pyenv
 
-### pyenv (macOS)
+On MacOS *pvtrace* can be installed easily using [pyenv](https://github.com/pyenv/pyenv) and `pip`.
 
-If using macOS you may want to use [pyenv](https://github.com/pyenv/pyenv) to create a clean virtual environment for pvtrace.
+Create a clean virtual environment for pvtrace
 
     pyenv virtualenv 3.7.2 pvtrace-env
     pyenv activate pvtrace-env
     pip install pvtrace
     # download https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/examples/hello_world.py
     python hello_world.py
 
-### conda (Windows, Linux and macOS)
+## Linux and Windows using Conda
 
-Conda can also be used but you must manually install the Rtree dependency *before* the `pip install pvtrace` command!
+On Linux and Windows you must use conda to create the python environment. Optionally you can also use this method on MacOS too if you prefer Conda over pyenv.
 
     conda create --name pvtrace-env python=3.7
     conda activate pvtrace-env
     conda install Rtree
     pip install pvtrace
     # download https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/examples/hello_world.py
     python hello_world.py
-    
-## Introduction
 
-pvtrace is a statistical photon path tracer written in Python. It follows photons through a 3D scene and records their interactions with objects to build up statistical information about energy flow. This approach is particularly useful in photovoltaics and non-imaging optics where the goal is to design systems which efficiently transport light to target locations.
+# Features
 
-## Documentation
+## Ray optics simulations
 
-Interactive Jupyter notebooks are in [examples directory](https://github.com/danieljfarrell/pvtrace/tree/master/examples), download and take a look, although they can be viewed online.
+*pvtrace* supports 3D ray optics simulations shapes,
 
-API documentation and some background at [https://pvtrace.readthedocs.io](https://pvtrace.readthedocs.io/)
+* box
+* sphere
+* cylinder
+* mesh
+
+The optical properties of each shape can be customised,
 
-## Capabilities
+* refractive index
+* absorption coefficient
+* scattering coefficient
+* emission lineshape
+* quantum yield
+* surface reflection
+* surface scattering
 
-pvtrace was originally written to characterise the performance of Luminescent Solar Concentrators (LSC) and takes a Monte-Carlo approach to ray-tracing. Each ray is independent and can interact with objects in the scene via reflection and refraction. Objects can have different optical properties: refractive index, absorption coefficient, emission spectrum and quantum yield.
+![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/docs/example.png)
 
-One of the key features of pvtrace is the ability to simulate re-absorption of photons in luminescent materials. This requires following thousands of rays to build intensity profiles and spectra of incoming and outgoing photons because these process cannot be approximated in a continuous way.
+## High and low-level API
 
-pvtrace may also be useful to researches or designers interested in ray-optics simulations but will be slower at running these simulations compared to other software packages because it follows each ray individually.
+*pvtrace* has a high-level API for handling common problems with LSCs and a low-level API where objects can be positioned in a 3D scene and optical properties customised.
 
-![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/docs/example.png)
-    
-A minimal working example that traces a glass sphere
+For example, a script using the low-level API to ray trace this glass sphere is below,
 
 ```python
 import time
@@ -60,6 +89,7 @@ import functools
 import numpy as np
 from pvtrace import *
 
+# World node contains all objects
 world = Node(
     name="world (air)",
     geometry=Sphere(
@@ -68,6 +98,7 @@ world = Node(
     )
 )
 
+# The glass sphere
 sphere = Node(
     name="sphere (glass)",
     geometry=Sphere(
@@ -78,12 +109,14 @@ sphere = Node(
 )
 sphere.location = (0, 0, 2)
 
+# The source of rays
 light = Node(
     name="Light (555nm)",
     light=Light(direction=functools.partial(cone, np.pi/8)),
     parent=world
 )
 
+# Render and ray-trace
 renderer = MeshcatRenderer(wireframe=True, open_browser=True)
 scene = Scene(world)
 renderer.render(scene)
@@ -102,12 +135,12 @@ while True:
         sys.exit()
 ```
 
-## Architecture
-
-![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/docs/pvtrace-design.png)
+## Scene Graph
 
 *pvtrace* is designed in layers each with as limited scope as possible.
 
+![](https://raw.githubusercontent.com/danieljfarrell/pvtrace/master/docs/pvtrace-design.png)
+
 <dl>
   <dt>Scene</dt>
   <dd>Graph data structure of node and the thing that is ray-traced.</dd>
@@ -126,15 +159,70 @@ while True:
 
   <dt>Components</dt>
   <dd>Specifies optical properties of the geometries volume, absorption coefficient, scattering coefficient, quantum yield, emission spectrum.</dd>
+  
+  <dt>Ray-tracing engine</dt>
+  <dd>The algorithm which spawns rays, computes intersections, samples probabilities and traverses the rays through the scene.</dd>
 </dl>
 
-## Dependancies
+## Ray-tracing engine
+
+Currently *pvtrace* supports only one ray-tracing engine: a photon path tracer. This is physically accurate, down to treating individual absorption and emission events, but is slow because the problem cannot be vectorised as each ray is followed individually.
+
+# Documentation
+
+Interactive Jupyter notebooks are in [examples directory](https://github.com/danieljfarrell/pvtrace/tree/master/examples), download and take a look, although they can be viewed online.
+
+API documentation and some background at [https://pvtrace.readthedocs.io](https://pvtrace.readthedocs.io/)
+
+# Contributing
+
+Please use the github [issue](https://github.com/danieljfarrell/pvtrace/issues) tracker for bug fixes, suggestions, or support questions.
+
+If you are considering contributing to pvtrace, first fork the project. This will make it easier to include your contributions using pull requests.
+
+## Creating a development environment
+
+1. First create a new development environment using [MacOS instructions](#macos-using-pyenv) or [Linux and Windows instructions](#linux-and-windows-using-conda), but do not install pvtrace using pip! You will need to clone your own copy of the source code in the following steps.
+2. Use the GitHub fork button to make your own fork of the project. This will make it easy to include your changes in pvtrace using a pull request.
+3. Follow the steps below to clone and install the development dependencies
+
+```bash
+# Pull from your fork
+git clone https://github.com/<your username>/pvtrace.git
+
+# Get development dependencies
+pip install -r pvtrace/requirements_dev.txt 
+
+# Add local `pvtrace` directory to known packages
+pip install -e pvtrace
+
+# Run units tests
+pytest pvtrace/tests
+
+# Run an example
+python pvtrace/examples/hello_world.py
+```
+
+You should now be able to edit the source code and simply run scripts directly without the need to reinstall anything.
+
+## Unit tests
+
+Please add or modify an existing unit tests in the `pvtrace/tests` directory if you are adding new code. This will make it much easier to include your changes in the project.
+
+## Pull requests
+
+Pull requests will be considered. Please make contact before doing a lot of work, to make sure that the changes will definitely be included in the main project.
+
+# Questions
+
+You can get in contact with me directly at dan@excitonlabs.com or raise an issue on the issue tracker.
+
+# Dependencies
 
 Basic environment requires the following packages which will be installed with `pip` automatically
 
 * python >= 3.7.2
 * numpy
 * trimesh[easy]
 * meshcat >= 0.0.16
-* anytree
-
+* anytree

docs/pvtrace-demo.gif

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -74,34 +74,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "You can open the visualizer by visiting the following URL:\n",
-      "http://127.0.0.1:7000/static/\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "<div style=\"height: 400px; width: 600px; overflow-x: auto; overflow-y: hidden; resize: both\">\n",
-       "<iframe src=\"http://127.0.0.1:7000/static/\" style=\"width: 100%; height: 100%; border: none\"></iframe>\n",
-       "</div>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "renderer = MeshcatRenderer(wireframe=True)\n",
     "renderer.render(scene)\n",
@@ -110,24 +85,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8de155093a2942e6956d4acc8b4644ec",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='x', max=0.6, min=-0.6, step=0.01), FloatSlider(value…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "_ = interact_ray(scene, renderer)"
    ]
@@ -141,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -172,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,20 +142,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'GENERATE: Ray(pos=(0.00, 0.00, 0.00), dir=(0.00, 0.00, 1.00), nm=555.00, alive=True)'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r, e = steps[0]\n",
     "f\"{e.name}: {r}\""
@@ -210,20 +159,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'TRANSMIT: Ray(pos=(0.00, 0.00, 1.00), dir=(0.00, 0.00, 1.00), nm=555.00, alive=True)'"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r, e = steps[1]\n",
     "f\"{e.name}: {r}\""
@@ -238,20 +176,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'EXIT: Ray(pos=(0.00, 0.00, 10.00), dir=(0.00, 0.00, 1.00), nm=555.00, alive=True)'"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "r, e = steps[2]\n",
     "f\"{e.name}: {r}\""
@@ -307,7 +234,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.2"
+   "version": "3.7.6"
   }
  },
  "nbformat": 4,

examples/001 Quick Start.ipynb

@@ -0,0 +1,40 @@
+import time
+import sys
+import functools
+import numpy as np
+from pvtrace import *
+import logging
+logging.getLogger('trimesh').setLevel(logging.CRITICAL)
+
+world = Node(
+    name="world (air)",
+    geometry=Sphere(
+        radius=50.0,
+        material=Material(refractive_index=1.0),
+    )
+)
+
+box = Node(
+    name="sphere (glass)",
+    geometry=Box(
+        (10.0, 10.0, 1.0),
+        material=Material(refractive_index=1.5),
+    ),
+    parent=world
+)
+
+light = Node(
+    name="Light (555nm)",
+    light=Light(),
+    parent=world
+)
+light.rotate(np.radians(60), (1.0, 0.0, 0.0))
+
+start_t = time.time()
+scene = Scene(world)
+for ray in scene.emit(100):
+    steps = photon_tracer.follow(scene, ray)
+
+print(f"Took {time.time() - start_t}s to trace 100 rays.")
+
+

examples/Luminescent solar concentrators.ipynb

@@ -36,16 +36,18 @@
     parent=world
 )
 cil1.translate((0, 0, 2))
+cil1.rotate(np.pi*0.2, (0, 1, 0))
 
 cil2 = Node(
     name="B",
     geometry=Cylinder(
-        length=0.5,
+        length=2.0,
         radius=0.4,
-        material=Material(refractive_index=6.0),
+        material=Material(refractive_index=1.5),
     ),
     parent=cil1
 )
+cil2.rotate(np.pi/2, (1, 0, 0))
 
 # Add source of photons
 light = Node(
@@ -65,7 +67,7 @@
 viewer = MeshcatRenderer(open_browser=True, transparency=False, opacity=0.5, wireframe=True)
 scene = Scene(world)
 viewer.render(scene)
-for ray in scene.emit(100):
+for ray in scene.emit(20):
     history = photon_tracer.follow(scene, ray)
     path, events = zip(*history)
     viewer.add_ray_path(path)  

examples/Validation.ipynb

@@ -1,11 +1,14 @@
-__version__ = "2.1.3.dev0"
+__version__ = "2.1.3"
 """
 Optical ray tracing for luminescent materials and spectral converter photovoltaic devices
 """
 import logging
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger("pvtrace")
+logging.getLogger("trimesh").setLevel(logging.CRITICAL)
+logging.getLogger("shapely.geos").setLevel(logging.CRITICAL)
+
 
 # Import commonly used classes to pvtrace namespace so users don't
 # have to understand module layout.
@@ -14,7 +17,9 @@
 from .algorithm import photon_tracer
 
 # data
-from .data import lumogen_f_red_305
+from .data import lumogen_f_red_305, fluro_red
+
+from .device.lsc import LSC
 
 # geometry
 from .geometry.box import Box
@@ -30,11 +35,7 @@
 
 
 # material
-from .material.component import (
-    Scatterer,
-    Absorber,
-    Luminophore,
-)
+from .material.component import Scatterer, Absorber, Luminophore
 from .material.distribution import Distribution
 from .material.material import Material
 from .material.surface import (

examples/Validation.png

@@ -174,7 +174,7 @@ def follow(scene, ray, maxsteps=1000, maxpathlength=np.inf, emit_method="kT"):
             component = material.component(ray.wavelength)
             if component.is_radiative(ray):
                 ray = component.emit(
-                    ray.representation(scene.root, container), emit_method=emit_method
+                    ray.representation(scene.root, container), method=emit_method
                 )
                 ray = ray.representation(container, scene.root)
                 if isinstance(component, Luminophore):

examples/hello_box.py

@@ -0,0 +1,103 @@
+import numpy as np
+from scipy.special import erf
+
+def absorption(x):
+    """ Fit to Coumarin Fluro Red absorption coefficient spectrum using four Gaussians.
+    
+        Parameters
+        ----------
+        x : numpy.array
+            Wavelength array in nanometers. This should take values in the optical 
+            range between 200 and 900.
+
+        Returns
+        -------
+        numpy.array
+            The spectrum normalised to peak value of 1.0.
+
+        Notes
+        -----
+        This fit is "good enough" for getting sensible answers but for research purposes
+        you should be using your own data as this might not be exactly the same 
+        spectrum as your materials.
+
+        Example
+        -------
+        To make a absorption coefficient spectrum in the range 300 to 800 nanometers
+        containing 200 points::
+
+            spectrum = absorption(np.linspace(300, 800, 200))
+    """
+    p1 = 549.06438843562137
+    a1 = 439.06754804626956
+    w1 = 24.298601639828647
+    
+    p2 = 379.48645797468572
+    a2 = 85.177292848284353
+    w2 = 13.513987279089216
+    
+    p3 = 519.58858977131513
+    a3 = 660.1731296017241
+    w3 = 38.263352007649125
+    
+    p4 = 490.05625608592726
+    a4 = 511.11501615291041
+    w4 = 52.213294432464529
+    spec = (
+        a1 * np.exp(-(((p1 - x) / w1) ** 2))
+        + a2 * np.exp(-(((p2 - x) / w2) ** 2))
+        + a3 * np.exp(-(((p3 - x) / w3) ** 2))
+        + a4 * np.exp(-(((p4 - x) / w4) ** 2))
+    )
+    spec = spec / np.max(spec)
+    return spec
+
+
+def emission(x):
+    """ Fit to Coumarin Fluro Red emission spectrum using an exponentially modified 
+        Gaussian.
+
+        Parameters
+        ----------
+        x : numpy.array
+            Wavelength array in nanometers. This should take values in the optical 
+            range between 200 and 900.
+
+        Returns
+        -------
+        numpy.array
+            The spectrum normalised to peak value of 1.0
+
+        Notes
+        -----
+        This fit is "good enough" for getting sensible answers but for research purposes
+        you should be using your own data as this might not be exactly the same 
+        spectrum as your materials.
+
+        Example
+        -------
+        To make a emission spectrum in the range 300 to 800 nanometers containing 200 
+        points::
+
+            spectrum = emission(np.linspace(300, 800, 200))
+    """
+    def emg(x, a, b, c, d):
+        r2 = np.sqrt(2)
+        return a * c * np.sqrt(2 * np.pi) / (2 * d) * \
+            np.exp((c**2/(2*d**2))-((x-b)/d)) * \
+            (d/np.abs(d) + erf((x - b)/(r2*c) - c/(r2*d)))
+    
+    a = 1.1477763237584664
+    b = 592.06478874548839
+    c = 19.981040318195117
+    d = 12.723704058786568
+    spec = emg(x, a, b, c, d)
+    return spec
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    x = np.arange(200, 900)
+    plt.plot(x, absorption(x), label="absorption")
+    plt.plot(x, emission(x), label="emission")
+    plt.grid(linestyle='dashed')
+    plt.show()

examples/nested_cylinders.py

@@ -376,6 +376,8 @@ def allinrange(x, x_range):
         x_range : tuple of float
             A tuple defining a range like (xmin, xmax)
     """
+    if isinstance(x, (int, float, np.float, np.int)):
+        x = np.array([x])
     return np.where(np.logical_or(x < x_range[0], x > x_range[1]))[0].size == 0
 
 

pvtrace/__init__.py

@@ -302,6 +302,7 @@ def emit(self, ray: "Ray", method="kT", T=300.0, **kwargs) -> "Ray":
         nm = ray.wavelength
         # Different ways of sampling the emission distribution.
         if method == "kT":
+            # Known issue: this can blue shift outside simulation range!
             # Emission energy can be within 3kT above current value. Simple bolzmann.
             eV = 1240.0 / nm
             eV = eV + 3 / 2 * kB * T  # Assumes 3 dimensional degrees of freedom

pvtrace/algorithm/photon_tracer.py

@@ -77,7 +77,7 @@ def __call__(self, x):
                 return self._y
 
         if not allinrange(x, self._x_range):
-            raise ValueError("x is outside data range.")
+            raise ValueError("x is outside data range.", {"x": x, "x_range": self._x_range})
 
         if self.hist:
             idx = np.searchsorted(self._edges[:-1], x)
@@ -122,7 +122,7 @@ def lookup(self, x):
 
         """
         if not allinrange(x, self._x_range):
-            raise ValueError("x is outside data range.")
+            raise ValueError("x is outside data range.", {"x": x, "x_range": self._x_range})
 
         if self.hist:
             idx = np.searchsorted(self._edges[:-1], x)

pvtrace/data/fluro_red.py

@@ -17,7 +17,7 @@
    author='Daniel Farrell',
    author_email='dan@excitonlabs.com',
    url='https://github.com/danieljfarrell/pvtrace',
-   download_url = 'https://github.com/danieljfarrell/pvtrace/archive/v2.1.2.tar.gz',
+   download_url = 'https://github.com/danieljfarrell/pvtrace/archive/v{}.tar.gz'.format(__version__),
    python_requires='>=3.7.2',
    packages=find_packages(),
    keywords=[

pvtrace/device/lsc.py

@@ -0,0 +1,106 @@
+import pytest
+import sys
+import os
+import numpy as np
+import pandas as pd
+from pvtrace import LSC, Distribution, rectangular_mask
+from pvtrace.data import fluro_red
+
+
+@pytest.fixture(scope='module')
+def lsc():
+    """ Compares an LSC simulation to 3D thermodynamic
+        radiative transfer model
+         
+        A.J, Chatten et al. https://doi.org/10.1134/1.1787111
+    
+        Expected fractions:
+        - edge = 0.25
+        - escape = 0.66
+        - loss = 0.09
+    """
+    x = np.arange(400, 801, dtype=np.float)
+    size = (l, w, d) = (4.8, 1.8, 0.250)  # cm-1
+    lsc = LSC(size, wavelength_range=x)
+
+    lsc.add_luminophore(
+        'Fluro Red',
+        np.column_stack((x, fluro_red.absorption(x) * 11.387815)),  # cm-1
+        np.column_stack((x, fluro_red.emission(x))),
+        quantum_yield=0.95
+    )
+    
+    lsc.add_absorber(
+        'PMMA',
+        0.02 # cm-1
+    )
+    
+    def lamp_spectrum(x):
+        """ Fit to an experimentally measured lamp spectrum with long wavelength filter.
+        """
+        def g(x, a, p, w):
+            return a * np.exp(-(((p - x) / w)**2 ))
+        a1 = 0.53025700136646192
+        p1 = 512.91400020614333
+        w1 = 93.491838802960473
+        a2 = 0.63578999789955015
+        p2 = 577.63100003089369
+        w2 = 66.031706473985736
+        return g(x, a1, p1, w1) + g(x, a2, p2, w2)
+    
+    lamp_dist = Distribution(x, lamp_spectrum(x))
+    wavelength_callable = lambda : lamp_dist.sample(np.random.uniform())
+    position_callable = lambda : rectangular_mask(l/2, w/2)
+    lsc.add_light(
+        "Oriel Lamp + Filter",
+        (0.0, 0.0, 0.5 * d + 0.01),  # put close to top surface
+        rotation=(np.radians(180), (1, 0, 0)),  # normal and into the top surface
+        wavelength=wavelength_callable,  # wavelength delegate callable
+        position=position_callable  # uniform surface illumination
+    )
+    
+    throw = 300
+    lsc.simulate(throw, emit_method='redshift')
+    return lsc
+
+@pytest.mark.skip(reason="Takes to long to include in unit general tests.")
+def test_edge(lsc):
+    incident = float(
+        len(
+            lsc.spectrum(
+                source={"Oriel Lamp + Filter"},
+                kind='first',
+                facets={'top'}
+            )
+        )
+    )
+    edge = len(lsc.spectrum(facets={'left', 'right', 'near', 'far'}, source='all'))
+    assert np.isclose(edge/incident, 0.25, atol=0.04)
+
+@pytest.mark.skip(reason="Takes to long to include in unit general tests.")
+def test_escape(lsc):
+    incident = float(
+        len(
+            lsc.spectrum(
+                source={"Oriel Lamp + Filter"},
+                kind='first',
+                facets={'top'}
+            )
+        )
+    )
+    escape = len(lsc.spectrum(facets={'top', 'bottom'}, source='all'))
+    assert np.isclose(escape/incident, 0.64, atol=0.04)
+
+@pytest.mark.skip(reason="Takes to long to include in unit general tests.")
+def test_lost(lsc):
+    incident = float(
+        len(
+            lsc.spectrum(
+                source={"Oriel Lamp + Filter"},
+                kind='first',
+                facets={'top'}
+            )
+        )
+    )
+    lost = len(lsc.spectrum(source='all', events={'absorb'}))
+    assert np.isclose(lost/incident, 0.11, atol=0.04)