def test_QWP_SS(self):
""" Test that S polarised light passing through a quarter wave plate at
0° degrees to the vertical, reflecting off a mirror then passing back
through the same waveplate results in S polarised light.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Waveplate, 'qwp', ('n1', 'n2'))
model.add_component(ts.components.Mirror, 'outMirror', 'n3')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n3'))
model.add_detector('out', 'n0', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['qwp'].rotation = 0
model.components['qwp'].retardance = np.pi / 2
model.components['qwp'].update()
model.build()
model.evaluate()
back_intensity_P = np.abs(model.detectors['out'].amplitudes[2])**2
back_intensity_S = np.abs(model.detectors['out'].amplitudes[3])**2
self.assertAlmostEqual(back_intensity_P, 0)
self.assertAlmostEqual(back_intensity_S, 1)
def test_45(self):
"""Test that vertically (S) polarised light passing through an 45°
polarising linear polariser results in pure 45° polarised light.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Polariser, 'inPol', ('n1', 'n2'))
model.add_component(ts.components.Dump, 'outDump', 'n3')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 'sOut', ('n2', 'n3'))
model.add_detector('out', 'n3', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['inPol'].rotation = np.pi / 4
model.components['inPol'].extinction = 0
model.components['inPol'].loss = 0
model.components['inPol'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0],
model.detectors['out'].amplitudes[1])
def test_ideal(self):
"""Test that 45° polarised light reflected off of an ideal mirror
through an isolator does not reach the source.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.IdealIsolator, 'isolator',
('n1', 'n2'))
model.add_component(ts.components.Mirror, 'mirror', 'n3')
model.add_component(ts.components.Stack, 's01', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's23', ('n2', 'n3'))
model.add_detector('out', 'n0', ('amplitude'))
model.components['laser'].amplitude[0] = 1 / np.sqrt(2)
model.components['laser'].amplitude[1] = 1 / np.sqrt(2)
model.components['mirror'].rP = 1
model.components['mirror'].rS = 1
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0],
1 / np.sqrt(2))
self.assertAlmostEqual(model.detectors['out'].amplitudes[1],
1 / np.sqrt(2))
self.assertAlmostEqual(model.detectors['out'].amplitudes[2], 0)
self.assertAlmostEqual(model.detectors['out'].amplitudes[3], 0)
def test_extinction(self):
"""Test that 45° polarised light passing through an S polarising
linear polariser with an extinction ratio of 0.01 results in the
correct output intensities for each polarisation.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Polariser, 'inPol', ('n1', 'n2'))
model.add_component(ts.components.Dump, 'outDump', 'n3')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 'sOut', ('n2', 'n3'))
model.add_detector('out', 'n3',
('amplitude', 'S intensity', 'P intensity'))
model.components['laser'].amplitude[0] = 1
model.components['laser'].amplitude[1] = 1
model.components['inPol'].rotation = 0
model.components['inPol'].extinction = 0.01
model.components['inPol'].loss = 0
model.components['inPol'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(
model.detectors['out'].P_intensity /
model.detectors['out'].S_intensity, 0.01)
def test_LHC(self):
"""Test passing left hand circularly polarised light through a stack
to a dump and detector.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Dump, 'dump', 'n1')
model.add_component(ts.components.Stack, 'stack', ('n0', 'n1'))
model.add_detector('out', 'n1', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 1
model.components['laser'].amplitude[1] = 1j
model.components['laser'].amplitude = \
model.components['laser'].amplitude / np.sqrt(2)
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0],
1 / np.sqrt(2))
self.assertAlmostEqual(model.detectors['out'].amplitudes[1],
1j / np.sqrt(2))
self.assertAlmostEqual(model.detectors['out'].intensity, 1)
def test_extinction(self):
""" Test that 45° polarised light passing through a polarising
beamsplitter with a transmission extinction of 0.01 and a reflection
extinction of 0.02 results in the correct intensity outputs.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.PolarisingBeamSplitter, 'pbs',
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Dump, 'd1', 'n5')
model.add_component(ts.components.Dump, 'd2', 'n6')
model.add_component(ts.components.Dump, 'd3', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n5'))
model.add_component(ts.components.Stack, 's2', ('n3', 'n6'))
model.add_component(ts.components.Stack, 's3', ('n4', 'n7'))
model.add_detector(
'pd1', 'n5',
('amplitude', 'intensity', 'S intensity', 'P intensity'))
model.add_detector(
'pd2', 'n6',
('amplitude', 'intensity', 'S intensity', 'P intensity'))
model.add_detector('pd3', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 1
model.components['laser'].amplitude[1] = 1
model.components['pbs'].rExtinction = 0.02
model.components['pbs'].tExtinction = 0.01
model.components['pbs'].rLoss = 0
model.components['pbs'].tLoss = 0
model.components['pbs'].theta0 = 0
model.components['pbs'].theta1 = 0
model.components['pbs'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(
model.detectors['pd1'].intensity +
model.detectors['pd2'].intensity, 2)
self.assertAlmostEqual(
model.detectors['pd1'].P_intensity /
model.detectors['pd1'].S_intensity,
model.components['pbs'].rExtinction)
self.assertAlmostEqual(
model.detectors['pd2'].S_intensity /
model.detectors['pd2'].P_intensity,
model.components['pbs'].tExtinction)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[1], 0)
def test_isolator(self):
"""Test that S polarised light passing through a Faraday isolator
consisting of an S polarising polariser, a 45° Faraday rotator and a
45° rotated polariser is correctly isolated.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Polariser, 'inPol', ('n1', 'n2'))
model.add_component(ts.components.FaradayRotator, 'fr', ('n3', 'n4'))
model.add_component(ts.components.Polariser, 'outPol', ('n5', 'n6'))
model.add_component(ts.components.Mirror, 'mirror', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n3'))
model.add_component(ts.components.Stack, 's2', ('n4', 'n5'))
model.add_component(ts.components.Stack, 'sOut', ('n6', 'n7'))
model.add_detector('out', 'n0', ('amplitude', 'intensity'))
model.add_detector('mir', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['fr'].rotation = np.pi / 4
model.components['fr'].update()
model.components['inPol'].rotation = 0
model.components['inPol'].extinction = 0
model.components['inPol'].loss = 0
model.components['inPol'].update()
model.components['outPol'].rotation = np.pi / 4
model.components['outPol'].extinction = 0
model.components['outPol'].loss = 0
model.components['outPol'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(np.abs(model.detectors['mir'].amplitudes[0]),
1 / np.sqrt(2))
self.assertAlmostEqual(np.abs(model.detectors['mir'].amplitudes[1]),
1 / np.sqrt(2))
self.assertAlmostEqual(
np.sign(model.detectors['mir'].amplitudes[1] *
model.detectors['mir'].amplitudes[0]), 1)
self.assertAlmostEqual(model.detectors['out'].amplitudes[2], 0)
self.assertAlmostEqual(model.detectors['out'].amplitudes[3], 0)
def test_set_length(self):
"""Test that the set_length method produces the correct phase changes.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Dump, 'dump', 'n1')
model.add_component(ts.components.Stack, 'stack', ('n0', 'n1'))
model.add_detector('out', 'n1', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 1
model.components['laser'].amplitude[1] = 1
model.components['stack'].set_length(0)
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0], 1)
self.assertAlmostEqual(model.detectors['out'].amplitudes[1], 1)
model.components['stack'].set_length(0.25)
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0],
np.exp(1j * 2 * np.pi * 0.25))
self.assertAlmostEqual(model.detectors['out'].amplitudes[1],
np.exp(1j * 2 * np.pi * 0.25))
model.components['stack'].set_length(0.634)
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0],
np.exp(1j * 2 * np.pi * 0.634))
self.assertAlmostEqual(model.detectors['out'].amplitudes[1],
np.exp(1j * 2 * np.pi * 0.634))
model.components['stack'].set_length(0, loss=0.5)
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].intensity, 1)
def test_HWP_SP(self):
"""Test that S polarised light passing through a half wave plate at 45°
degrees to the vertical results in P polarised light.
Polarisers are used to filter inputs and outputs; the polariser unit
tests should be run first to ensure any issues can reasonably be
isolated to the waveplate.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Polariser, 'inPol', ('n1', 'n2'))
model.add_component(ts.components.Waveplate, 'hwp', ('n3', 'n4'))
model.add_component(ts.components.Polariser, 'outPol', ('n5', 'n6'))
model.add_component(ts.components.Dump, 'outDump', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n3'))
model.add_component(ts.components.Stack, 's2', ('n4', 'n5'))
model.add_component(ts.components.Stack, 'sOut', ('n6', 'n7'))
model.add_detector('out', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['hwp'].rotation = np.pi / 4
model.components['hwp'].retardance = np.pi
model.components['hwp'].update()
model.components['inPol'].rotation = 0
model.components['inPol'].extinction = 0
model.components['inPol'].loss = 0
model.components['inPol'].update()
model.components['outPol'].rotation = np.pi / 2
model.components['outPol'].extinction = 0
model.components['outPol'].loss = 0
model.components['outPol'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].intensity, 1)
def test_45(self):
"""Test that 45° polarised light passing through an unrotated
polarising beamsplitter produces S and P polarised beams.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.PolarisingBeamSplitter, 'pbs',
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Dump, 'd1', 'n5')
model.add_component(ts.components.Dump, 'd2', 'n6')
model.add_component(ts.components.Dump, 'd3', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n5'))
model.add_component(ts.components.Stack, 's2', ('n3', 'n6'))
model.add_component(ts.components.Stack, 's3', ('n4', 'n7'))
model.add_detector('pd1', 'n5', ('amplitude', 'intensity'))
model.add_detector('pd2', 'n6', ('amplitude', 'intensity'))
model.add_detector('pd3', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = np.sqrt(2)
model.components['laser'].amplitude[1] = np.sqrt(2)
model.components['pbs'].rExtinction = 0
model.components['pbs'].tExtinction = 0
model.components['pbs'].rLoss = 0
model.components['pbs'].tLoss = 0
model.components['pbs'].theta0 = 0
model.components['pbs'].theta1 = 0
model.components['pbs'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['pd1'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['pd1'].amplitudes[1],
np.sqrt(2))
self.assertAlmostEqual(model.detectors['pd2'].amplitudes[0],
np.sqrt(2))
self.assertAlmostEqual(model.detectors['pd2'].amplitudes[1], 0)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[1], 0)
def test_S(self):
"""Test that S polarised light passing through a beamsplitter produces
two equal intensity S polarised beams.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.BeamSplitter, 'bs',
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Dump, 'd1', 'n5')
model.add_component(ts.components.Dump, 'd2', 'n6')
model.add_component(ts.components.Dump, 'd3', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n5'))
model.add_component(ts.components.Stack, 's2', ('n3', 'n6'))
model.add_component(ts.components.Stack, 's3', ('n4', 'n7'))
model.add_detector('pd1', 'n5', ('amplitude', 'intensity'))
model.add_detector('pd2', 'n6', ('amplitude', 'intensity'))
model.add_detector('pd3', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['pd1'].amplitudes[0], 0)
self.assertAlmostEqual(
model.detectors['pd1'].amplitudes[1],
1 / np.sqrt(2))
self.assertAlmostEqual(model.detectors['pd2'].amplitudes[0], 0)
self.assertAlmostEqual(
model.detectors['pd2'].amplitudes[1],
1 / np.sqrt(2))
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[1], 0)
self.assertAlmostEqual(model.detectors['pd1'].intensity, 0.5)
self.assertAlmostEqual(model.detectors['pd2'].intensity, 0.5)
self.assertAlmostEqual(model.detectors['pd3'].intensity, 0)
def test_loss(self):
"""Test that 45° polarised light passing through a polarising
beamsplitter with 10% intensity loss for the reflected beam and 20%
loss for the transmitted beam results in the correct output intensity.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.PolarisingBeamSplitter, 'pbs',
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Dump, 'd1', 'n5')
model.add_component(ts.components.Dump, 'd2', 'n6')
model.add_component(ts.components.Dump, 'd3', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n5'))
model.add_component(ts.components.Stack, 's2', ('n3', 'n6'))
model.add_component(ts.components.Stack, 's3', ('n4', 'n7'))
model.add_detector('pd1', 'n5', ('amplitude', 'intensity'))
model.add_detector('pd2', 'n6', ('amplitude', 'intensity'))
model.add_detector('pd3', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 1
model.components['laser'].amplitude[1] = 1
model.components['pbs'].rExtinction = 0
model.components['pbs'].tExtinction = 0
model.components['pbs'].sLoss = 0.9
model.components['pbs'].pLoss = 0.8
model.components['pbs'].theta0 = 0
model.components['pbs'].theta1 = 0
model.components['pbs'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['pd1'].intensity, 0.9)
self.assertAlmostEqual(model.detectors['pd2'].intensity, 0.8)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['pd3'].amplitudes[1], 0)
def test_theta1(self):
""" Test that S polarised light passing through a polarising beam
splitter (from the first node) rotated by 45° about the axis from the
first to the third node results in an even distribution of light in
both outputs.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.PolarisingBeamSplitter, 'pbs',
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Dump, 'd1', 'n5')
model.add_component(ts.components.Dump, 'd2', 'n6')
model.add_component(ts.components.Dump, 'd3', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n2'))
model.add_component(ts.components.Stack, 's1', ('n1', 'n5'))
model.add_component(ts.components.Stack, 's2', ('n3', 'n6'))
model.add_component(ts.components.Stack, 's3', ('n4', 'n7'))
model.add_detector('pd1', 'n5', ('amplitude', 'intensity'))
model.add_detector('pd2', 'n6', ('amplitude', 'intensity'))
model.add_detector('pd3', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['pbs'].rExtinction = 0
model.components['pbs'].tExtinction = 0
model.components['pbs'].rLoss = 0
model.components['pbs'].tLoss = 0
model.components['pbs'].theta0 = 0
model.components['pbs'].theta1 = np.pi / 4
model.components['pbs'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['pd1'].intensity, 0.5)
self.assertAlmostEqual(model.detectors['pd2'].intensity, 0)
self.assertAlmostEqual(model.detectors['pd3'].intensity, 0.5)
def test_rot(self):
"""Test that S polarised light passing through a Faraday rotator with a
rotation of 45° results in light polarised at 45°.
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Polariser, 'inPol', ('n1', 'n2'))
model.add_component(ts.components.FaradayRotator, 'fr', ('n3', 'n4'))
model.add_component(ts.components.Polariser, 'outPol', ('n5', 'n6'))
model.add_component(ts.components.Dump, 'outDump', 'n7')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.Stack, 's1', ('n2', 'n3'))
model.add_component(ts.components.Stack, 's2', ('n4', 'n5'))
model.add_component(ts.components.Stack, 'sOut', ('n6', 'n7'))
model.add_detector('out', 'n7', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
model.components['fr'].rotation = np.pi / 4
model.components['fr'].update()
model.components['inPol'].rotation = 0
model.components['inPol'].extinction = 0
model.components['inPol'].loss = 0
model.components['inPol'].update()
model.components['outPol'].rotation = np.pi / 4
model.components['outPol'].extinction = 0
model.components['outPol'].loss = 0
model.components['outPol'].update()
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].intensity, 1)
###
# This script produces Figure 7 in "Polarisation-sensitive transfer matrix
# modelling for displacement measuring interferometry", A. Bridges, A. Yacoot,
# T. Kissinger and R. P. Tatam.
#
# Last updated by Angus Bridges, 24/03/2020.
###
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
import strapy as ts
import pyctmm
model = ts.Model()
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Stack, 'sIn', ('n0', 'n1'))
model.add_component(ts.components.PolarisingBeamSplitter, 'pbs', \
('n1', 'n2', 'n3', 'n4'))
model.add_component(ts.components.Stack, 'sRefA', ('n2', 'n5'))
model.add_component(ts.components.Waveplate, 'qwpRef', ('n5', 'n6'))
model.add_component(ts.components.Stack, 'sRefB', ('n6', 'n7'))
model.add_component(ts.components.Mirror, 'mRef', 'n7')
model.add_component(ts.components.Stack, 'sMesA', ('n3', 'n8'))
model.add_component(ts.components.Waveplate, 'qwpMes', ('n8', 'n9'))
model.add_component(ts.components.Stack, 'sMesB', ('n9', 'n10'))
model.add_component(ts.components.Mirror, 'mMes', 'n10')
model.add_component(ts.components.Stack, 'sOutA', ('n4', 'n11'))
model.add_component(ts.components.BeamSplitter, 'npbs', \
('n11', 'n12', 'n13', 'nNPBSdumpA'))
def test_set_pyctmm_free_space(self):
"""Test that the set_ctmm method produces the correct results.
This does not aim to fully test the pyctmm library, but tests a few
simple cases:
phase change through free space
reflection from air-glass interface
destructive interference at air-glass interface (half-wave layer)
"""
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Dump, 'dump', 'n1')
model.add_component(ts.components.Stack, 'stack', ('n0', 'n1'))
model.add_detector('out', 'n1', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
cstack = pyctmm.create_stack(1, model.wavelength, 0)
pyctmm.set_ind(cstack, 0, 1, 0)
pyctmm.set_d(cstack, 0, model.wavelength / 4)
model.components['stack'].set_pyctmm(cstack)
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['out'].amplitudes[0], 0)
self.assertAlmostEqual(model.detectors['out'].amplitudes[1],
np.exp(-1j * np.pi / 2))
self.assertAlmostEqual(model.detectors['out'].amplitudes[2], 0)
self.assertAlmostEqual(model.detectors['out'].amplitudes[3], 0)
del cstack
del model
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Dump, 'dump', 'n1')
model.add_component(ts.components.Stack, 'stack', ('n0', 'n1'))
model.add_detector('in', 'n0', ('amplitude', 'intensity'))
model.add_detector('out', 'n1', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
cstack = pyctmm.create_stack(2, model.wavelength, 0)
pyctmm.set_ind(cstack, 0, 1, 0)
pyctmm.set_ind(cstack, 1, 1.5, 0)
pyctmm.set_d(cstack, 0, 0)
pyctmm.set_d(cstack, 1, 0)
model.components['stack'].set_pyctmm(cstack)
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['in'].intensity - 1,
((1 - 1.5) / (1 + 1.5))**2)
del cstack
del model
model = ts.Model()
model.wavelength = 633e-9
model.add_component(ts.components.Source, 'laser', 'n0')
model.add_component(ts.components.Dump, 'dump', 'n1')
model.add_component(ts.components.Stack, 'stack', ('n0', 'n1'))
model.add_detector('in', 'n0', ('amplitude', 'intensity'))
model.add_detector('out', 'n1', ('amplitude', 'intensity'))
model.components['laser'].amplitude[0] = 0
model.components['laser'].amplitude[1] = 1
cstack = pyctmm.create_stack(3, model.wavelength, 0)
pyctmm.set_ind(cstack, 0, 1, 0)
pyctmm.set_ind(cstack, 1, 1.515, 0)
pyctmm.set_ind(cstack, 2, 1, 0)
pyctmm.set_d(cstack, 0, 0)
pyctmm.set_d(cstack, 1, (model.wavelength / 1.515) / 2)
pyctmm.set_d(cstack, 2, 0)
model.components['stack'].set_pyctmm(cstack)
model.build()
model.evaluate()
self.assertAlmostEqual(model.detectors['in'].intensity - 1, 0)
self.assertAlmostEqual(model.detectors['out'].intensity, 1)
except:
print("\nmatplotlib is not installed, install now (y/n)?")
installFlag = input()
if installFlag == 'y':
import subprocess
import sys
subprocess.check_call(
[sys.executable, "-m", "pip", "install", "matplotlib"])
try:
from matplotlib import pyplot as plt
except:
print("matplotlib is still not installed, exiting.\n")
exit()
model = strapy.Model()
model.add_component(strapy.components.Source, 'laser', 'n0')
model.add_component(strapy.components.BeamSplitter, 'BS',
('n1', 'n2', 'n3', 'n4'))
model.add_component(strapy.components.Mirror, 'Mmes', 'n5')
model.add_component(strapy.components.Mirror, 'Mref', 'n6')
model.add_component(strapy.components.Polariser, 'pol', ('n7', 'n8'))
model.add_component(strapy.components.Stack, 's01', ('n0', 'n1'))
model.add_component(strapy.components.Stack, 's35', ('n3', 'n5'))
model.add_component(strapy.components.Stack, 's26', ('n2', 'n6'))
model.add_component(strapy.components.Stack, 's47', ('n4', 'n7'))
model.add_component(strapy.components.Stack, 's89', ('n8', 'n9'))
model.add_component(strapy.components.Dump, 'd9', 'n9')
model.add_detector('PD1', 'n9', ('amplitude', 'intensity'))
