Polarizing components v2 (#25)

* add PolarizationFilter

* consider global object orientation

* decrease test atol for normal3d to 2e-14

* test Jones matrix rotation

* wip: AbstractJonesMatrix for xy or sp dispatch

* SPBasis constructor test

* Jmat tests

* cacl global E0 for orthogonally aligned J matrix (pol.-filter)

* norm dir vectors in isparallel3d

* new test for Jones/Yun calc.

* move utils into subfolder, split into subfiles for better oversight. Add Sellmeier equation + testset

* add get_view, set_view, hide_axis to ext. internals

* add more render presets

* fix include MiscUtils.jl

* add pd docs, refer to intensity and optical_power

* add visibility util fct

* fix lens render preset

* add removal todo - GB constructor

* add bisection fct changes (this will suck to merge lmao)

* bug fixes for #22 and #23

* rn XYBasis to XZBasis

* add pol. state utils

* add tests for pol. state utils and isparallel+ isorthogonal

* scuffed patch for thin film polarizing elements without ray dir change

* fix mutation bug in islinear

* Review fixes

* rename pol. filter files and dir, add testset for pol filter, add PolRay beam constructor

* add polfilter docs

* rm redundant mm def. from runtests.jl

* up vn to 0.10.2

* polarizer docs

Author: StackEnjoyer

Project.toml

@@ -1,7 +1,7 @@
 name = "BeamletOptics"
 uuid = "c387492b-ffec-4e51-9a46-bd230226031c"
 authors = ["Hugo Uittenbosch <hugo.uittenbosch@dlr.de>, Oliver Kliebisch <oliver.kliebisch@dlr.de> and Thomas Dekorsy <thomas.dekorsy@dlr.de>"]
-version = "0.10.1"
+version = "0.10.2"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"

docs/make.jl

@@ -49,6 +49,7 @@ makedocs(;
             "Lenses" => "components/lenses.md",
             "Beamsplitters" => "components/beamsplitters.md",
             "Detectors" => "components/detectors.md",
+            "Polarizers" => "components/polarizers.md",
         ],
         "Developer Documentation" => Any[
             "Dev. guide" => "guide.md",

docs/src/assets/photodetector_showcase.jl

@@ -12,9 +12,6 @@ system = System([pd])
 g1 = GaussianBeamlet([0,-20e-3,0], [0,1,1e-3], 532e-9, 1e-5)
 g2 = GaussianBeamlet([0,-20e-3,0], [0,1,0], 532e-9, 5e-4)
 
-ϕ = 0
-g2.E0 *= exp(im*ϕ)
-
 solve_system!(system, g1)
 solve_system!(system, g2)
 

docs/src/basics/rays.md

@@ -28,7 +28,7 @@ This ray type is able to model reflection and [refraction](https://www.rp-photon
 
 ## Polarized Rays
 
-In order to model the effect of polarizing elements, e.g. a ``\lambda/4``-plate, the polarization ray tracing calculus of Yun et. al is used [Yun2011_1, Yun2011_2](@cite). This formalism allows to model the effects of said elements on the electric field vector ``E_0`` using the [Jones formalism](https://www.rp-photonics.com/polarization_of_light.html) in global coordinates:
+In order to model the effect of polarizing elements, the polarization ray tracing calculus of Yun et. al is used [Yun2011_1, Yun2011_2](@cite). This formalism allows to model the effects of said elements on the electric field vector ``E_0`` using the [Jones formalism](https://www.rp-photonics.com/polarization_of_light.html) in global coordinates:
 
 ```@docs; canonical=false
 PolarizedRay

docs/src/components/components.md

@@ -5,7 +5,7 @@ A collection of basic optical elements is provided with this package as is. They
 ## Component overview
 
 ```@contents
-Pages = ["mirrors.md", "lenses.md", "beamsplitters.md", "detectors.md"]
+Pages = ["mirrors.md", "lenses.md", "beamsplitters.md", "detectors.md", "polarizers.md"]
 Depth = 2
 ```
 ## Listing available components

docs/src/components/polarizers.md

@@ -0,0 +1,46 @@
+# Polarizers
+
+Polarizers in the context of this package are optical elements that select or modify the R³ polarization vector of a [`PolarizedRay`](@ref), e.g. filters or λ/2 waveplates. This is mainly done by two approaches:
+
+1. 3D polarization ray-tracing calculus
+2. 3D modified Jones matrix calculus
+
+For more information on the first method refer to the section: [Polarized Rays](@ref). For the second approach, elements fall under the category of the [`BeamletOptics.AbstractJonesPolarizer`](@ref).
+
+```@docs; canonical=false
+BeamletOptics.AbstractJonesPolarizer
+```
+
+## Jones matrix element representation
+
+Fundamentally, the approach used here to simulate the effect of polarizers is referred to as [Jones calculus](https://en.wikipedia.org/wiki/Jones_calculus) and gives a "0th order" approximation of the physical effect. Out of plane tilts with respect to the optical axis of an incoming ray are currently only considered via a projection into the transverse plane of the incoming ray [Korger2013](@cite).
+
+In a nutshell, elements are characterized by a 2x2 matrix that determines how the E-field components in the transverse plane to the optical axis are passed through in a global coordinate system where a ray of polarized light propagates along the z-axis. For instance, the entries for a linear filter that blocks in the y-direction are
+
+```math
+J = 
+\begin{pmatrix}
+1 & 0\\
+0 & 0
+\end{pmatrix} \,.
+```
+
+While this allows to simply model a specific set of polarizing elements, its important to note that more complex phenomena need more extensive implementations. For 3D-calculations, the ``J``-matrix representation is embedded into 
+
+```math
+P =
+\begin{bmatrix}
+  J & \begin{matrix}0 \\ 0\end{matrix} \\
+  \begin{matrix}0 & 0\end{matrix} & 1
+\end{bmatrix}
+```
+
+in order to calculate ``\vec{E}_1 = P \cdot \vec{E}_0`` for normal incidence. Additional details are provided in the docs above.
+
+## Polarisation filter
+
+A polarisation filter or linear polarizer is the simplest practical polarizer and is commonly used to select a desired polarization state. This package provides the [`PolarizationFilter`](@ref) as an idealized implementation for a zero-thickness filter.
+
+```@docs; canonical=false
+PolarizationFilter(::Real)
+```

docs/src/index.md

@@ -78,6 +78,7 @@ In order to warrant a 1.0.0 release tag, the following features will need to be
         - 🔳 Wave plates (λ/2 and λ/4)
         - 🔳 Retarders
         - 🔳 Faraday rotators
+        - ✅ Polarizing thin-film filters
     - 🔳 Isolators
     - 🔳 Modulators
         - 🔳 AOM

docs/src/refs.bib

@@ -30,6 +30,22 @@ @article{Yun2011_2
   abstract = {The concept of retardance is critically analyzed for ray paths through optical systems described by a three-by-three polarization ray-tracing matrix. Algorithms are presented to separate the effects of retardance from geometric transformations. The geometric transformation described by a ``parallel transport matrix'' characterizes nonpolarizing propagation through an optical system, and also provides a proper relationship between sets of local coordinates along the ray path. The proper retardance is calculated by removing this geometric transformation from the three-by-three polarization ray-tracing matrix. Two rays with different ray paths through an optical system can have the same polarization ray-tracing matrix but different retardances. The retardance and diattenuation of an aluminum-coated three fold-mirror system are analyzed as an example.},
 }
 
+@article{Korger2013,
+  author = {Jan Korger and Tobias Kolb and Peter Banzer and Andrea Aiello and Christoffer Wittmann and Christoph Marquardt and Gerd Leuchs},
+  journal = {Opt. Express},
+  keywords = {Polarimetry; Ellipsometry and polarimetry; Polarization; Beam splitters; Liquid crystal displays; Mueller matrices; Optical components; Optical elements; Polarizers},
+  number = {22},
+  pages = {27032--27042},
+  publisher = {Optica Publishing Group},
+  title = {The polarization properties of a tilted polarizer},
+  volume = {21},
+  month = {Nov},
+  year = {2013},
+  url = {https://opg.optica.org/oe/abstract.cfm?URI=oe-21-22-27032},
+  doi = {10.1364/OE.21.027032},
+  abstract = {Polarizers are key components in optical science and technology. Thus, understanding the action of a polarizer beyond oversimplifying approximations is crucial. In this work, we study the interaction of a polarizing interface with an obliquely incident wave experimentally. To this end, a set of Mueller matrices is acquired employing a novel procedure robust against experimental imperfections. We connect our observation to a geometric model, useful to predict the effect of polarizers on complex light fields.},
+}
+
 @book{Fowles1989,
   title={Introduction to Modern Optics},
   author={Fowles, G.R.},

ext/BeamletOpticsMakieExt.jl

@@ -1,11 +1,11 @@
 module BeamletOpticsMakieExt
 
 using BeamletOptics
-import BeamletOptics: render!, RenderException, _RenderTypes
+import BeamletOptics: render!, RenderException, _RenderTypes, get_view, set_view, hide_axis
 
 const BMO = BeamletOptics
 
-using Makie: Axis3, LScene, mesh!, surface!, lines!, RGBAf, scatter!
+using Makie: Axis3, LScene, mesh!, surface!, lines!, RGBf, RGBAf, scatter!
 using GeometryBasics: Point2, Point3
 using AbstractTrees: PreOrderDFS
 using MarchingCubes: MC, march
@@ -50,4 +50,36 @@ include("RenderLenses.jl")
 include("RenderCylinderLenses.jl")
 include("RenderPresets.jl")
 
+"""
+    get_view(ls::LScene)
+
+Returns the current `eyeposition`, `lookat` and `upvector` of the scene `ls`.
+"""
+function get_view(ls::LScene)
+    cam = ls.scene.camera_controls
+    eye = cam.eyeposition[]
+    lookat = cam.lookat[]
+    up = cam.upvector[]
+    return eye, lookat, up
+end
+
+"""
+    set_view(ls::LScene, eye, lookat, up)
+
+Sets the current `eyeposition`, `lookat` and `upvector` of the scene `ls`.
+"""
+function set_view(ls::LScene, eye, lookat, up)
+    cam = ls.scene.camera_controls
+    cam.eyeposition[] = eye
+    cam.lookat[] = lookat
+    cam.upvector[] = up
+end
+
+"""
+    hide_axis(ls::LScene, hide::Bool=true)
+
+Hides the axis markers in the `LScene`. Can be toggled via `hide`.
+"""
+hide_axis(ls::LScene, hide::Bool=true) = (ls.show_axis[] = !hide)
+
 end

ext/RenderPresets.jl

@@ -1,6 +1,10 @@
 render!(ax::_RenderEnv, refr::BMO.AbstractRefractiveOptic; kwargs...) = _render!(ax, refr; transparency=true, color=:white, kwargs...)
 render!(ax::_RenderEnv, refl::BMO.AbstractReflectiveOptic; kwargs...) = _render!(ax, refl; transparency=false, color=:silver, kwargs...)
 
+render!(ax::_RenderEnv, lens::Lens; kwargs...) = _render!(ax, lens; transparency=true, color=RGBf(0.678, 0.847, 0.902), alpha=0.5, kwargs...)
+
 render!(ax::_RenderEnv, bs::ThinBeamsplitter; kwargs...) = _render!(ax, bs; transparency=true, color=:magenta, kwargs...)
 
-render!(ax::_RenderEnv, nino::BMO.NonInteractableObject; kwargs...) = _render!(ax, nino; transparency=false, color=:grey, kwargs...)
+render!(ax::_RenderEnv, nino::BMO.NonInteractableObject; kwargs...) = _render!(ax, nino; transparency=false, color=:grey, kwargs...)
+
+render!(ax::_RenderEnv, nino::BMO.IntersectableObject; kwargs...) = _render!(ax, nino; transparency=true, color=:grey, alpha=0.1)