diffinytrace 2.1__py3-none-any.whl

diffinytrace/plotting/system3D.py

@@ -0,0 +1,327 @@
+# Copyright (c) 2025 Martin Pflaum
+# This file is part of the diffinytrace project, licensed under the MIT License.
+
+__all__ = [
+    "ray_paths_one_bin",
+    "ray_paths",
+    "surface",
+    "get_optical_system_layout",
+    "_plot_surface",
+    "_plot_surface_recursively",
+    "plot"
+]
+
+import pandas as pd
+import torch
+import plotly.express as px
+import plotly.graph_objects as go
+import numpy as np
+#import matplotlib.pyplot as plt
+#from PIL import Image
+#import tempfile
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+import matplotlib.colors as mcolors
+import plotly.io as pio
+import copy
+
+##2013FF
+def ray_paths_one_bin(rays,ray_color,ray_linewidth):
+    """
+    Generate a Plotly 3D line plot for a group of rays with the same number of segments.
+
+    Args:
+        rays (list[torch.Tensor]): List of ray paths, each as a tensor.
+        ray_color (str): Color for the ray lines.
+        ray_linewidth (float): Line width for the ray lines.
+
+    Returns:
+        plotly.graph_objs.Figure: Plotly figure containing the ray paths.
+    """
+    rays = [elem.numpy() for elem in rays]
+    rays = np.array(rays)
+    rays = torch.tensor(rays)
+    x = rays[:,:,0].reshape(-1)
+    y = rays[:,:,1].reshape(-1)
+    z = rays[:,:,2].reshape(-1)
+    ray_id = torch.arange(rays.shape[1]).reshape(-1,1).repeat(1,rays.shape[0]).T.reshape(-1)
+    df = pd.DataFrame({"X":x,"Y":y,"Z":z,"ray id":ray_id})
+
+    line_fig = px.line_3d(df, x='X', y='Y', z='Z', line_group="ray id")
+
+    for k in range(len(line_fig.data)):
+        line_fig.data[k].line.color = ray_color
+        line_fig.data[k].line.width = ray_linewidth
+    return line_fig
+
+def ray_paths(rays,ray_color="#9673A6",ray_linewidth=3):
+    """
+    Generate Plotly line objects for multiple ray paths, grouped by path length.
+
+    Args:
+        rays (list[torch.Tensor]): List of rays to plot.
+        ray_color (str): Color of the rays.
+        ray_linewidth (float): Line width of the rays.
+
+    Returns:
+        list: List of Plotly line objects for each ray group.
+    """
+    ray_color = mcolors.to_hex(ray_color)
+    data = []
+    if not rays is None:
+        ray_path_bins = {}
+        for elem in rays:
+            if not len(elem) in ray_path_bins.keys():
+                ray_path_bins[len(elem)] = []
+            ray_path_bins[len(elem)] += [elem]
+        for key in ray_path_bins.keys():
+            line_fig = ray_paths_one_bin(ray_path_bins[key],ray_color,ray_linewidth)
+            data += [*line_fig.data]
+    return data
+
+
+def surface(transformation,surface,name,aperture_radius,resolution,colorscale,is_square=False):
+    """
+    Generate a Plotly surface plot for an optical element.
+
+    Args:
+        transformation: Transformation object for the optical element.
+        surface: Surface object to plot.
+        name (str): Name of the surface.
+        aperture_radius (float): Radius of the aperture.
+        resolution (int): Resolution for the surface plot.
+        colorscale (list): Color scale for the surface plot.
+        is_square (bool): Whether the aperture is square or circular.
+
+    Returns:
+        list: List of Plotly surface objects.
+    """
+    
+    _x = torch.linspace(-aperture_radius,aperture_radius,resolution)
+    _y = torch.linspace(-aperture_radius,aperture_radius,resolution)
+    mesh = torch.meshgrid(_x,_y)
+    x = mesh[0].reshape(-1)
+    y = mesh[1].reshape(-1)
+    O = torch.zeros((x.shape[0],3))
+    
+    if not is_square:
+        mul = (torch.sqrt(x*x+y*y)>aperture_radius).float()/torch.sqrt(x*x+y*y)*aperture_radius
+        mul += (torch.sqrt(x*x+y*y)<aperture_radius).float()
+        x = x*mul
+        y = y*mul
+            
+    
+    O[:,0] = x
+    O[:,1] = y
+    z = None
+    
+    with torch.no_grad():
+        z = surface.explicit(O)
+    z = z.detach().reshape(-1)
+    x = x.detach().reshape(-1)
+    y = y.detach().reshape(-1)
+    v = torch.zeros((x.shape[0],4))
+    v[:,0] = x
+    v[:,1] = y
+    v[:,2] = z
+    v[:,3] = torch.ones_like(v[:,3])   
+    
+    Mv = None
+    with torch.no_grad():
+        M = transformation.get_transformation_matrix().detach()
+        Mv = v@M.T
+
+    x = Mv[:,0].reshape(_x.shape[0],_x.shape[0])
+    y = Mv[:,1].reshape(_x.shape[0],_x.shape[0])
+    z = Mv[:,2].reshape(_x.shape[0],_x.shape[0])
+
+    data = []
+    data += [go.Surface(x=x, y=y, z=z,showscale=False,name=name,colorscale=colorscale)]
+    return data
+
+
+def get_optical_system_layout(show_grid,xlabel="x [mm]",ylabel="y [mm]",zlabel="z [mm]",xticks=None,yticks=None,zticks=None,axislabel_font_size=10,tick_font_size=10):
+    """
+    Create a Plotly layout for 3D visualization of the optical system.
+
+    Args:
+        show_grid (bool): Whether to show the grid.
+        xlabel (str): Label for the x-axis.
+        ylabel (str): Label for the y-axis.
+        zlabel (str): Label for the z-axis.
+        xticks (list[float], optional): Custom x-ticks.
+        yticks (list[float], optional): Custom y-ticks.
+        zticks (list[float], optional): Custom z-ticks.
+        axislabel_font_size (int): Font size for axis labels.
+        tick_font_size (int): Font size for tick labels.
+
+    Returns:
+        plotly.graph_objs.Layout: Layout object for the plot.
+    """
+    #TODO write wrapper for plot3D!
+    camera = dict(
+        up=dict(x=1., y=0., z=0)
+    )
+    xaxis=dict(
+        visible=show_grid,
+        title=dict(text=xlabel, font=dict(size=axislabel_font_size)),  # X axis title font size
+        tickfont=dict(size=tick_font_size)  # X axis tick labels font size
+    )
+    yaxis=dict(
+        visible=show_grid,
+        title=dict(text=ylabel, font=dict(size=axislabel_font_size)),  # Y axis title font size
+        tickfont=dict(size=tick_font_size)  # Y axis tick labels font size
+    )
+    zaxis=dict(
+        visible=show_grid,
+        title=dict(text=zlabel, font=dict(size=axislabel_font_size)),  # Z axis title font size
+        tickfont=dict(size=tick_font_size)  # Z axis tick labels font size
+    )
+
+    if xticks is not None:
+        xaxis["tickvals"] = xticks
+    if yticks is not None:
+        yaxis["tickvals"] = yticks
+
+    if zticks is not None:
+        zaxis["tickvals"] = zticks
+
+    scene = dict(
+        xaxis=xaxis,
+        yaxis=yaxis,
+        zaxis=zaxis,
+        aspectmode='data',
+        aspectratio = dict(x=1, y=1, z=1),
+    )
+    """    scene = dict(
+        xaxis = dict(visible=show_axis),
+        yaxis = dict(visible=show_axis),
+        zaxis = dict(visible=show_axis),
+        aspectmode='data',
+        aspectratio = dict(x=1, y=1, z=1),
+        xaxis_title='x [mm]',
+        yaxis_title='y [mm]',
+        zaxis_title='z [mm]')
+    """
+    layout = go.Layout(scene_camera=camera,scene=scene)
+    return layout
+
+
+def _plot_surface(surface,name,resolution):
+    """
+    Generate Plotly surface objects for all 3D surface segments of an element.
+
+    Args:
+        surface: Object with get_plot_points_3D and get_plotly_color_scale methods.
+        name (str): Name for the surface.
+        resolution (int): Resolution for the surface plot.
+
+    Returns:
+        list: List of Plotly surface objects.
+    """
+    surface_list = surface.get_plot_points_3D(resolution)
+    if len(surface_list)==0:
+        return []
+    colorscale = surface.get_plotly_color_scale()
+            
+    data = []
+    for k,(x,y,z) in enumerate(surface_list):
+        try:
+            data += [go.Surface(x=x, y=y, z=z,showscale=False,name=name+f"_{k}",colorscale=colorscale[k])]
+        except:
+            print("Wrong number of colorscales or colorscales is not correct, fallback to first colorscale!")
+            data += [go.Surface(x=x, y=y, z=z,showscale=False,name=name+f"_{k}",colorscale=colorscale[0])]
+        
+    return data
+
+
+def _plot_surface_recursively(current_elem,name,resolution):
+    """
+    Recursively generate Plotly surface objects for an element and its plotable children.
+
+    Args:
+        current_elem: The current plotable element.
+        name (str): Name for the element.
+        resolution (int): Resolution for the surface plot.
+
+    Returns:
+        list: List of Plotly surface objects for the element and its children.
+    """
+    out = _plot_surface(current_elem,name,resolution)
+    for elem,elem_name in current_elem.get_plotable_childs():
+        out += _plot_surface_recursively(elem,elem_name,resolution)
+    return out
+
+def plot(element=None,
+         rays=None,
+         resolution=32,
+         show_grid=True,
+         xlabel="x [mm]",
+         ylabel="y [mm]",
+         zlabel="z [mm]",
+         xticks=None,
+         yticks=None,
+         zticks=None,
+         axislabel_font_size=10,
+         tick_font_size=10,
+         ray_color="#9673A6",
+         ray_linewidth=3.,
+         show=True,
+         html_file_name=None):
+    """
+    Visualize the optical system and ray paths in 3D using Plotly.
+
+    Args:
+        element: The optical system element to plot (must implement Plotable interface).
+        rays (list[torch.Tensor] or dict): List of rays or dict containing ray paths.
+        resolution (int): Resolution for the surface plot.
+        show_grid (bool): Whether to show the grid.
+        xlabel (str): Label for the x-axis.
+        ylabel (str): Label for the y-axis.
+        zlabel (str): Label for the z-axis.
+        xticks (list[float], optional): Custom x-ticks.
+        yticks (list[float], optional): Custom y-ticks.
+        zticks (list[float], optional): Custom z-ticks.
+        axislabel_font_size (int): Font size for axis labels.
+        tick_font_size (int): Font size for tick labels.
+        ray_color (str): Color of the rays.
+        ray_linewidth (float): Line width of the rays.
+        show (bool): Whether to display the plot immediately.
+        html_file_name (str, optional): If provided, saves the plot as an HTML file.
+
+    Returns:
+        plotly.graph_objs.Figure or None: The Plotly figure object if show is False, otherwise None.
+    """
+    
+    data = []
+    if isinstance(element,(list,tuple)):
+        for subelem in element:
+            subelem = copy.deepcopy(subelem)
+            subelem = subelem.to("cpu")
+            data += _plot_surface_recursively(subelem,"",resolution)
+
+    elif not element is None:
+        element = copy.deepcopy(element)
+        element = element.to("cpu")
+        data += _plot_surface_recursively(element,"",resolution)
+        
+    if not rays is None:
+        if isinstance(rays,dict):
+            rays = rays["ray_paths"]
+
+        rays = [elem.cpu() for elem in rays]
+        data += ray_paths(rays,ray_color,ray_linewidth)
+    layout = get_optical_system_layout(show_grid,xlabel,ylabel,zlabel,xticks,yticks,zticks,axislabel_font_size,tick_font_size)
+    fig = go.Figure(data=data,layout=layout)
+    if show:
+        fig.show()
+
+    if not html_file_name is None:
+        if html_file_name[-5:]!=".html":
+            raise RuntimeError("html_file_name should end with .html!")
+
+        pio.write_html(fig, file=html_file_name, auto_open=False)
+    
+    if not show:
+        return fig

diffinytrace/plotting/wavelength.py

@@ -0,0 +1,231 @@
+# Copyright (c) 2025 Martin Pflaum
+# This file is part of the diffinytrace project, licensed under the MIT License.
+
+__all__ = [
+    "PlotableWavelength",
+    "add_colour_bar",
+    "plot"
+]
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+from colour import XYZ_to_sRGB,wavelength_to_XYZ
+from typing import Tuple,Optional,Union
+
+class PlotableWavelength:
+    """
+    Represents a wavelength range and y-axis label for plotting spectral data.
+
+    Attributes:
+        bounds (tuple): Lower and upper bounds for the wavelength range.
+        ylabel (str): Label for the y-axis in plots.
+    """
+
+    def __init__(self, bounds: Tuple[float, float], ylabel: str):
+        self.bounds = bounds
+        self.ylabel = ylabel
+
+def add_colour_bar(fig, ax, wl):
+    """
+    Add a color strip below the plot to represent the wavelength spectrum.
+    
+    Args:
+        fig (matplotlib.figure.Figure): The figure object.
+        ax (matplotlib.axes.Axes): The main axis of the plot.
+        wl (array-like): Wavelengths in µm.
+    """
+    left, bottom, width, height = ax.get_position().bounds
+    color_ax = fig.add_axes([left, bottom - 0.15, width, 0.03])  # Position further below to avoid overlap
+    
+    def wavelength_to_rgb(wl):
+        wl = wl*1000.
+        if 360.0 < wl and wl < 780.0:
+            rgb = XYZ_to_sRGB(wavelength_to_XYZ(wl))
+            return np.clip(rgb, 0.0, 1.0)  # Ensure RGB values are within [0, 1]
+        else:
+            return (0.,0.,0.)
+
+    colors = [wavelength_to_rgb(_wl) for _wl in wl]
+        
+    for i in range(len(wl) - 1):
+        color_ax.fill_between([wl[i], wl[i + 1]], 0, 1, color=colors[i])
+        
+    color_ax.set_xlim(np.min(wl),np.max(wl))
+    color_ax.axis('off')  # Hide axis for a clean color strip
+
+#TODO change bmin and bmax to bounds
+#refractive_index
+def plot(wl,vals=None,title="",xlabel="Wavelength [µm]",ylabel="y",labels=None,colour_bar=True,linewidth=2,legend=True,resolution=500,show=True):
+    """
+    Plot a spectrum with a color strip below it.
+
+    Args:
+        wl (array-like): Wavelengths in nm or µm.
+        vals (array-like): Values of the spectrum at the given wavelengths.
+        title (str): Title of the plot.
+        xlabel (str): Label for the x-axis.
+        ylabel (str): Label for the y-axis.
+        labels (list): Labels for the different curves.
+        colour_bar (bool): Whether to show a color bar.
+        linewidth (int): Line width of the plot.
+        legend (bool): Whether to show a legend.
+        resolution (int): Resolution of the plot.
+        show (bool): Whether to show the plot.
+
+    Returns:
+        None
+    """
+    if vals is None:
+        if not isinstance(wl,PlotableWavelength):
+            raise RuntimeError("if vals=None, wl must be a PlotableWavelength!")
+        plotable_func = wl
+        wl = np.linspace(*plotable_func.bounds,resolution)
+        vals = plotable_func(wl)
+        if ylabel=="y":
+            ylabel = plotable_func.ylabel
+    # Create figure and main axis
+    fig, ax = plt.subplots(figsize=(10, 5))
+    plt.subplots_adjust(bottom=0.3)  # Increase space at the bottom
+    vals = np.array(vals)
+    
+    wl = np.array(wl)
+    if (wl>100.).any():
+        print("wl is µm not nm! Setting wl to µm")
+        wl = wl/1000.
+    
+    
+    vmin = np.min(vals)
+    vmax = np.max(vals)
+    
+    if len(vals.shape) == 1:
+        val = vals
+        vmin = np.min(val)
+        ax.plot(wl, val, color='black', linewidth=linewidth)
+        ax.fill_between(wl, val, color='gray', alpha=0.2)
+    else:
+        if vals.shape[1] != wl.shape[0]:
+            vals = vals.T
+    
+        for i in range(len(vals)):
+            val = vals[i]
+            label = None
+            if labels is not None:
+                label = labels[i]
+            ax.plot(wl, val,label=label, linewidth=linewidth)
+            
+    
+    ax.set_xlim(np.min(wl),np.max(wl))
+    ax.set_ylim(vmin,vmax+(vmax-vmin)*0.1)
+    
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.set_title(title)
+    if colour_bar:
+        add_colour_bar(fig, ax, wl)
+    
+    if labels is not None:
+        if legend:
+            ax.legend(loc='upper right')
+    if show:
+        plt.show()
+
+    
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+import colour
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import colour
+
+# Define the wavelength range (in nm) and the spectrum curve (e.g., Gaussian example)
+
+bmin = 300.
+bmax = 3000.
+wavelengths = np.linspace(bmin, bmax, 1000)
+spectrum = np.exp(-((wavelengths - 550) / 40) ** 2)  # Gaussian curve centered at 550 nm
+
+# Function to map wavelength to RGB color
+def wavelength_to_rgb(wavelength):
+    if 360.0 < wavelength and wavelength < 780.0:
+        rgb = colour.XYZ_to_sRGB(colour.wavelength_to_XYZ(wavelength))
+        return np.clip(rgb, 0.0, 1.0)  # Ensure RGB values are within [0, 1]
+    else:
+        return (0.,0.,0.)
+def add_color_strip(ax, bmin, bmax, resolution=1000):
+    wavelengths = np.linspace(bmin, bmax, resolution)
+    
+    
+    colors = [wavelength_to_rgb(wl) for wl in wavelengths]
+    
+    # Create the color strip as a series of filled segments
+    for i in range(len(wavelengths) - 1):
+        ax.fill_between([wavelengths[i], wavelengths[i + 1]], 0, 1, color=colors[i])
+    
+    ax.set_xlim(bmin, bmax)
+    ax.axis('off')  # Hide axis for a clean color strip
+
+# Create figure and main axis
+fig, ax = plt.subplots(figsize=(10, 5))
+plt.subplots_adjust(bottom=0.3)  # Increase space at the bottom
+
+# Plot the spectrum curve
+ax.plot(wavelengths, spectrum, color='black', linewidth=2)
+ax.fill_between(wavelengths, spectrum, color='gray', alpha=0.2)
+
+# Add labels and limits for the main plot
+ax.set_xlim(bmin, bmax)
+ax.set_ylim(0, 1.1)
+ax.set_xlabel("Wavelength (nm)")
+ax.set_ylabel("Intensity (a.u.)")
+ax.set_title("Spectrum with Corresponding Colors")
+
+# Add an extra axis for the color strip below the main plot, with extra spacing
+left, bottom, width, height = ax.get_position().bounds
+color_ax = fig.add_axes([left, bottom - 0.15, width, 0.03])  # Position further below to avoid overlap
+add_color_strip(color_ax, bmin, bmax, resolution=1000)
+
+plt.show()
+#%%
+
+"""
+
+
+"""
+
+#%%
+import matplotlib.pyplot as plt
+import numpy as np
+import colour
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+import colour
+
+# Define the wavelength range (in nm) and the spectrum curve (e.g., Gaussian example)
+wavelengths = np.linspace(380, 780, 1000)
+spectrum = pvlib.spectrum.get_am15g(wavelengths)
+spectrum = np.array(spectrum)
+
+# Function to map wavelength to RGB color
+def wavelength_to_rgb(wavelength):
+    rgb = colour.XYZ_to_sRGB(colour.wavelength_to_XYZ(wavelength))
+    return np.clip(rgb, 0.0, 1.0)  # Ensure RGB values are within [0, 1]
+
+colors = [wavelength_to_rgb(wl) for wl in wavelengths]
+    
+    # Create the color strip as a series of filled segments
+fig, ax = plt.subplots(figsize=(10, 5))
+for i in range(len(wavelengths) - 1):
+    plt.fill_between([wavelengths[i], wavelengths[i + 1]], 0, spectrum[i+1], color=colors[i],interpolate=True)
+    
+# Plot the spectrum curve
+plt.xlim(380, 750)
+plt.ylim(0., 2.0)
+plt.plot(wavelengths, spectrum, color='black')
+plt.show()
+"""

diffinytrace/refractive_index.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2025 Martin Pflaum
+# This file is part of the diffinytrace project, licensed under the MIT License.
+
+
+__all__ = [
+    "RefractiveIndex",
+    "materials"
+]
+
+import torch.nn as nn
+import torch
+import numpy as np
+from .plotting.wavelength import PlotableWavelength
+
+class RefractiveIndex(nn.Module,PlotableWavelength):
+    r"""This class is used to calculate the refractive index of a material.
+    
+    At material interfaces, the transmitted direction :math:`\mathbf{D'}` is computed based on the surface normal 
+    :math:`\mathbf{N} = \nabla s / \|\nabla s\|` and the incident direction :math:`\mathbf{D}`, using Snell's law (see :cite:`do`):
+
+    .. math::
+
+        \mathbf{D'} = \mathbf{N} \sqrt{1 - (1 - \cos^2 \psi_i) \eta^2} + \eta (\mathbf{D} - \mathbf{N} \cos \psi_i),
+
+    where :math:`\cos \psi_i = \mathbf{D} \cdot \mathbf{N}` and :math:`\eta = n / n'` is the ratio of the refractive indices 
+    of the two materials.
+
+    We have implemented the refractive indices as a class that is initialized by a refractive index function and the start 
+    and end wavelengths for which the function is valid. This makes it very convenient to use with the RefractiveIndex.info 
+    database of optical constants (see :cite:`polyanskiy2024refractiveindex`), since this database often provides Python 
+    functions for wavelength-dependent refractive indices.
+
+    Example:
+        Below is an example of how to set up an optical material in our ray tracing library:
+
+        >>> import diffinytrace as dit
+        >>> BaSF = dit.RefractiveIndex(
+        >>>     lambda x: (1 + 1.65554268 / (1 - 0.0104485644 / x**2) +
+        >>>                   0.17131977 / (1 - 0.0499394756 / x**2) +
+        >>>                   1.33664448 / (1 - 118.961472 / x**2))**0.5,
+        >>>     [0.365, 2.5]
+        >>> )
+        >>> dit.plotting.wavelength.plot(
+        >>>     BaSF, title="Refractive index of BaSF (Barium dense flint)"
+        >>> )
+
+    Args:
+        func (callable): A function that takes a wavelength in μm and returns the refractive index.
+        bounds (tuple): A tuple containing the minimum and maximum wavelength in μm.
+    """
+    def __init__(self,func,bounds):
+        nn.Module.__init__(self)
+        PlotableWavelength.__init__(self,bounds,"n [1]")
+        self.func = func
+        self.bounds = bounds
+
+    def forward(self,wl):
+        """Calculates the refractive index for given wavelengths.
+        Args:
+            wl (torch.Tensor or float): Wavelength in μm.
+        Returns:
+            torch.Tensor: Refractive index at the given wavelengths.
+        """
+        if not torch.is_tensor(wl):
+            wl = torch.tensor(wl)
+        vmin,vmax = self.bounds
+        if not (((vmin <=wl).float()*(wl<=vmax).float())==1.0).all():
+            print(f"The wavelength should be given in μm and between {vmin} and {vmax}. Fallback to constant val.")
+
+
+        out = self.func(wl)
+        if isinstance(out,float):
+            return out*torch.ones_like(wl)
+        if isinstance(out,np.ndarray):
+            out = torch.tensor(out,device=wl.device,dtype=wl.dtype)
+
+        out[vmin > wl] = self.func(vmin)
+        out[wl>vmax] = self.func(vmax)
+         
+        if torch.is_tensor(out):
+            if len(out.shape) == 0:
+                return out*torch.ones_like(wl)
+        return out
+
+"""
+All material data is from https://refractiveindex.info/. Please verify the equation and ranges by ur self and the references.
+"""
+materials = {
+    "NONE": RefractiveIndex(lambda x: 1.0,(0.0,torch.inf)),
+    "AIR": RefractiveIndex(lambda x: 1+0.05792105/(238.0185-x**-2)+0.00167917/(57.362-x**-2),(0.23,1.69)),#P. E. Ciddor. Refractive index of air: new equations for the visible and near infrared, Appl. Optics 35, 1566-1573 (1996)
+    "HELIUM": RefractiveIndex(lambda x: (1+4977.77e-8/(1-28.54e-6/x**2)+1856.94e-8/(1-7.76e-3/x**2))**.5,(0.48,2.06)),#C. R. Mansfield and E. R. Peck. Dispersion of helium, J. Opt. Soc. Am. 59, 199-203 (1969)
+    "PMMA": RefractiveIndex(lambda x: (1+0.99654/(1-0.00787/x**2)+0.18964/(1-0.02191/x**2)+0.00411/(1-3.85727/x**2))**.5,(0.405,1.08)),#Marcin Szczurowski
+    "NBK7": RefractiveIndex(lambda x: (1+1.03961212/(1-0.00600069867/x**2)+0.231792344/(1-0.0200179144/x**2)+1.01046945/(1-103.560653/x**2))**.5,(0.3,2.5)),#SCHOTT
+    "BAF10": RefractiveIndex(lambda x: (1+1.5851495/(1-0.00926681282/x**2)+0.143559385/(1-0.0424489805/x**2)+1.08521269/(1-105.613573/x**2))**.5,(0.35,2.5)),#SCHOTT
+    "BAK1": RefractiveIndex(lambda x: (1+1.12365662/(1-0.00644742752/x**2)+0.309276848/(1-0.0222284402/x**2)+0.881511957/(1-107.297751/x**2))**.5,(0.3,2.5)),#SCHOTT
+    "FK51A": RefractiveIndex(lambda x: (1+0.971247817/(1-0.00472301995/x**2)+0.216901417/(1-0.0153575612/x**2)+0.904651666/(1-168.68133/x**2))**.5,(0.29,2.5)),#SCHOTT
+    "LASF9": RefractiveIndex(lambda x: (1+2.00029547/(1-0.0121426017/x**2)+0.298926886/(1-0.0538736236/x**2)+1.80691843/(1-156.530829/x**2))**.5,(0.365,2.5)),#SCHOTT
+    "SF5": RefractiveIndex(lambda x: (1+1.52481889/(1-0.011254756/x**2)+0.187085527/(1-0.0588995392/x**2)+1.42729015/(1-129.141675/x**2))**.5,(0.37,2.5)),#SCHOTT
+    "SF10": RefractiveIndex(lambda x: (1+1.62153902/(1-0.0122241457/x**2)+0.256287842/(1-0.0595736775/x**2)+1.64447552/(1-147.468793/x**2))**.5,(0.38,2.5)),#SCHOTT
+    "SF11": RefractiveIndex(lambda x: (1+1.73759695/(1-0.013188707/x**2)+0.313747346/(1-0.0623068142/x**2)+1.89878101/(1-155.23629/x**2))**.5,(0.37,2.5)),#SCHOTT
+}