switching to high quality piper tts and added label translations
This commit is contained in:
Matthias Hinrichs
@@ -0,0 +1,102 @@
|
||||
from sympy.core.evalf import N
|
||||
from sympy.core.numbers import (Float, I, oo, pi)
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import atan2
|
||||
from sympy.matrices.dense import Matrix
|
||||
from sympy.polys.polytools import factor
|
||||
|
||||
from sympy.physics.optics import (BeamParameter, CurvedMirror,
|
||||
CurvedRefraction, FlatMirror, FlatRefraction, FreeSpace, GeometricRay,
|
||||
RayTransferMatrix, ThinLens, conjugate_gauss_beams,
|
||||
gaussian_conj, geometric_conj_ab, geometric_conj_af, geometric_conj_bf,
|
||||
rayleigh2waist, waist2rayleigh)
|
||||
|
||||
|
||||
def streq(a, b):
|
||||
return str(a) == str(b)
|
||||
|
||||
|
||||
def test_gauss_opt():
|
||||
mat = RayTransferMatrix(1, 2, 3, 4)
|
||||
assert mat == Matrix([[1, 2], [3, 4]])
|
||||
assert mat == RayTransferMatrix( Matrix([[1, 2], [3, 4]]) )
|
||||
assert [mat.A, mat.B, mat.C, mat.D] == [1, 2, 3, 4]
|
||||
|
||||
d, f, h, n1, n2, R = symbols('d f h n1 n2 R')
|
||||
lens = ThinLens(f)
|
||||
assert lens == Matrix([[ 1, 0], [-1/f, 1]])
|
||||
assert lens.C == -1/f
|
||||
assert FreeSpace(d) == Matrix([[ 1, d], [0, 1]])
|
||||
assert FlatRefraction(n1, n2) == Matrix([[1, 0], [0, n1/n2]])
|
||||
assert CurvedRefraction(
|
||||
R, n1, n2) == Matrix([[1, 0], [(n1 - n2)/(R*n2), n1/n2]])
|
||||
assert FlatMirror() == Matrix([[1, 0], [0, 1]])
|
||||
assert CurvedMirror(R) == Matrix([[ 1, 0], [-2/R, 1]])
|
||||
assert ThinLens(f) == Matrix([[ 1, 0], [-1/f, 1]])
|
||||
|
||||
mul = CurvedMirror(R)*FreeSpace(d)
|
||||
mul_mat = Matrix([[ 1, 0], [-2/R, 1]])*Matrix([[ 1, d], [0, 1]])
|
||||
assert mul.A == mul_mat[0, 0]
|
||||
assert mul.B == mul_mat[0, 1]
|
||||
assert mul.C == mul_mat[1, 0]
|
||||
assert mul.D == mul_mat[1, 1]
|
||||
|
||||
angle = symbols('angle')
|
||||
assert GeometricRay(h, angle) == Matrix([[ h], [angle]])
|
||||
assert FreeSpace(
|
||||
d)*GeometricRay(h, angle) == Matrix([[angle*d + h], [angle]])
|
||||
assert GeometricRay( Matrix( ((h,), (angle,)) ) ) == Matrix([[h], [angle]])
|
||||
assert (FreeSpace(d)*GeometricRay(h, angle)).height == angle*d + h
|
||||
assert (FreeSpace(d)*GeometricRay(h, angle)).angle == angle
|
||||
|
||||
p = BeamParameter(530e-9, 1, w=1e-3)
|
||||
assert streq(p.q, 1 + 1.88679245283019*I*pi)
|
||||
assert streq(N(p.q), 1.0 + 5.92753330865999*I)
|
||||
assert streq(N(p.w_0), Float(0.00100000000000000))
|
||||
assert streq(N(p.z_r), Float(5.92753330865999))
|
||||
fs = FreeSpace(10)
|
||||
p1 = fs*p
|
||||
assert streq(N(p.w), Float(0.00101413072159615))
|
||||
assert streq(N(p1.w), Float(0.00210803120913829))
|
||||
|
||||
w, wavelen = symbols('w wavelen')
|
||||
assert waist2rayleigh(w, wavelen) == pi*w**2/wavelen
|
||||
z_r, wavelen = symbols('z_r wavelen')
|
||||
assert rayleigh2waist(z_r, wavelen) == sqrt(wavelen*z_r)/sqrt(pi)
|
||||
|
||||
a, b, f = symbols('a b f')
|
||||
assert geometric_conj_ab(a, b) == a*b/(a + b)
|
||||
assert geometric_conj_af(a, f) == a*f/(a - f)
|
||||
assert geometric_conj_bf(b, f) == b*f/(b - f)
|
||||
assert geometric_conj_ab(oo, b) == b
|
||||
assert geometric_conj_ab(a, oo) == a
|
||||
|
||||
s_in, z_r_in, f = symbols('s_in z_r_in f')
|
||||
assert gaussian_conj(
|
||||
s_in, z_r_in, f)[0] == 1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)
|
||||
assert gaussian_conj(
|
||||
s_in, z_r_in, f)[1] == z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)
|
||||
assert gaussian_conj(
|
||||
s_in, z_r_in, f)[2] == 1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)
|
||||
|
||||
l, w_i, w_o, f = symbols('l w_i w_o f')
|
||||
assert conjugate_gauss_beams(l, w_i, w_o, f=f)[0] == f*(
|
||||
-sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)) + 1)
|
||||
assert factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1]) == f*w_o**2*(
|
||||
w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))/w_i**2
|
||||
assert conjugate_gauss_beams(l, w_i, w_o, f=f)[2] == f
|
||||
|
||||
z, l, w_0 = symbols('z l w_0', positive=True)
|
||||
p = BeamParameter(l, z, w=w_0)
|
||||
assert p.radius == z*(pi**2*w_0**4/(l**2*z**2) + 1)
|
||||
assert p.w == w_0*sqrt(l**2*z**2/(pi**2*w_0**4) + 1)
|
||||
assert p.w_0 == w_0
|
||||
assert p.divergence == l/(pi*w_0)
|
||||
assert p.gouy == atan2(z, pi*w_0**2/l)
|
||||
assert p.waist_approximation_limit == 2*l/pi
|
||||
|
||||
p = BeamParameter(530e-9, 1, w=1e-3, n=2)
|
||||
assert streq(p.q, 1 + 3.77358490566038*I*pi)
|
||||
assert streq(N(p.z_r), Float(11.8550666173200))
|
||||
assert streq(N(p.w_0), Float(0.00100000000000000))
|
||||
@@ -0,0 +1,48 @@
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.physics.optics import Medium
|
||||
from sympy.abc import epsilon, mu, n
|
||||
from sympy.physics.units import speed_of_light, u0, e0, m, kg, s, A
|
||||
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
c = speed_of_light.convert_to(m/s)
|
||||
e0 = e0.convert_to(A**2*s**4/(kg*m**3))
|
||||
u0 = u0.convert_to(m*kg/(A**2*s**2))
|
||||
|
||||
|
||||
def test_medium():
|
||||
m1 = Medium('m1')
|
||||
assert m1.intrinsic_impedance == sqrt(u0/e0)
|
||||
assert m1.speed == 1/sqrt(e0*u0)
|
||||
assert m1.refractive_index == c*sqrt(e0*u0)
|
||||
assert m1.permittivity == e0
|
||||
assert m1.permeability == u0
|
||||
m2 = Medium('m2', epsilon, mu)
|
||||
assert m2.intrinsic_impedance == sqrt(mu/epsilon)
|
||||
assert m2.speed == 1/sqrt(epsilon*mu)
|
||||
assert m2.refractive_index == c*sqrt(epsilon*mu)
|
||||
assert m2.permittivity == epsilon
|
||||
assert m2.permeability == mu
|
||||
# Increasing electric permittivity and magnetic permeability
|
||||
# by small amount from its value in vacuum.
|
||||
m3 = Medium('m3', 9.0*10**(-12)*s**4*A**2/(m**3*kg), 1.45*10**(-6)*kg*m/(A**2*s**2))
|
||||
assert m3.refractive_index > m1.refractive_index
|
||||
assert m3 != m1
|
||||
# Decreasing electric permittivity and magnetic permeability
|
||||
# by small amount from its value in vacuum.
|
||||
m4 = Medium('m4', 7.0*10**(-12)*s**4*A**2/(m**3*kg), 1.15*10**(-6)*kg*m/(A**2*s**2))
|
||||
assert m4.refractive_index < m1.refractive_index
|
||||
m5 = Medium('m5', permittivity=710*10**(-12)*s**4*A**2/(m**3*kg), n=1.33)
|
||||
assert abs(m5.intrinsic_impedance - 6.24845417765552*kg*m**2/(A**2*s**3)) \
|
||||
< 1e-12*kg*m**2/(A**2*s**3)
|
||||
assert abs(m5.speed - 225407863.157895*m/s) < 1e-6*m/s
|
||||
assert abs(m5.refractive_index - 1.33000000000000) < 1e-12
|
||||
assert abs(m5.permittivity - 7.1e-10*A**2*s**4/(kg*m**3)) \
|
||||
< 1e-20*A**2*s**4/(kg*m**3)
|
||||
assert abs(m5.permeability - 2.77206575232851e-8*kg*m/(A**2*s**2)) \
|
||||
< 1e-20*kg*m/(A**2*s**2)
|
||||
m6 = Medium('m6', None, mu, n)
|
||||
assert m6.permittivity == n**2/(c**2*mu)
|
||||
# test for equality of refractive indices
|
||||
assert Medium('m7').refractive_index == Medium('m8', e0, u0).refractive_index
|
||||
raises(ValueError, lambda:Medium('m9', e0, u0, 2))
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
|
||||
jones_2_stokes, linear_polarizer, phase_retarder, half_wave_retarder,
|
||||
quarter_wave_retarder, transmissive_filter, reflective_filter,
|
||||
mueller_matrix, polarizing_beam_splitter)
|
||||
from sympy.core.numbers import (I, pi)
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.exponential import exp
|
||||
from sympy.matrices.dense import Matrix
|
||||
|
||||
|
||||
def test_polarization():
|
||||
assert jones_vector(0, 0) == Matrix([1, 0])
|
||||
assert jones_vector(pi/2, 0) == Matrix([0, 1])
|
||||
#################################################################
|
||||
assert stokes_vector(0, 0) == Matrix([1, 1, 0, 0])
|
||||
assert stokes_vector(pi/2, 0) == Matrix([1, -1, 0, 0])
|
||||
#################################################################
|
||||
H = jones_vector(0, 0)
|
||||
V = jones_vector(pi/2, 0)
|
||||
D = jones_vector(pi/4, 0)
|
||||
A = jones_vector(-pi/4, 0)
|
||||
R = jones_vector(0, pi/4)
|
||||
L = jones_vector(0, -pi/4)
|
||||
|
||||
res = [Matrix([1, 1, 0, 0]),
|
||||
Matrix([1, -1, 0, 0]),
|
||||
Matrix([1, 0, 1, 0]),
|
||||
Matrix([1, 0, -1, 0]),
|
||||
Matrix([1, 0, 0, 1]),
|
||||
Matrix([1, 0, 0, -1])]
|
||||
|
||||
assert [jones_2_stokes(e) for e in [H, V, D, A, R, L]] == res
|
||||
#################################################################
|
||||
assert linear_polarizer(0) == Matrix([[1, 0], [0, 0]])
|
||||
#################################################################
|
||||
delta = symbols("delta", real=True)
|
||||
res = Matrix([[exp(-I*delta/2), 0], [0, exp(I*delta/2)]])
|
||||
assert phase_retarder(0, delta) == res
|
||||
#################################################################
|
||||
assert half_wave_retarder(0) == Matrix([[-I, 0], [0, I]])
|
||||
#################################################################
|
||||
res = Matrix([[exp(-I*pi/4), 0], [0, I*exp(-I*pi/4)]])
|
||||
assert quarter_wave_retarder(0) == res
|
||||
#################################################################
|
||||
assert transmissive_filter(1) == Matrix([[1, 0], [0, 1]])
|
||||
#################################################################
|
||||
assert reflective_filter(1) == Matrix([[1, 0], [0, -1]])
|
||||
|
||||
res = Matrix([[S(1)/2, S(1)/2, 0, 0],
|
||||
[S(1)/2, S(1)/2, 0, 0],
|
||||
[0, 0, 0, 0],
|
||||
[0, 0, 0, 0]])
|
||||
assert mueller_matrix(linear_polarizer(0)) == res
|
||||
#################################################################
|
||||
res = Matrix([[1, 0, 0, 0], [0, 0, 0, -I], [0, 0, 1, 0], [0, -I, 0, 0]])
|
||||
assert polarizing_beam_splitter() == res
|
||||
@@ -0,0 +1,202 @@
|
||||
from sympy.core.numbers import comp, Rational
|
||||
from sympy.physics.optics.utils import (refraction_angle, fresnel_coefficients,
|
||||
deviation, brewster_angle, critical_angle, lens_makers_formula,
|
||||
mirror_formula, lens_formula, hyperfocal_distance,
|
||||
transverse_magnification)
|
||||
from sympy.physics.optics.medium import Medium
|
||||
from sympy.physics.units import e0
|
||||
|
||||
from sympy.core.numbers import oo
|
||||
from sympy.core.symbol import symbols
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.matrices.dense import Matrix
|
||||
from sympy.geometry.point import Point3D
|
||||
from sympy.geometry.line import Ray3D
|
||||
from sympy.geometry.plane import Plane
|
||||
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
|
||||
ae = lambda a, b, n: comp(a, b, 10**-n)
|
||||
|
||||
|
||||
def test_refraction_angle():
|
||||
n1, n2 = symbols('n1, n2')
|
||||
m1 = Medium('m1')
|
||||
m2 = Medium('m2')
|
||||
r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
|
||||
i = Matrix([1, 1, 1])
|
||||
n = Matrix([0, 0, 1])
|
||||
normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
|
||||
P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
|
||||
assert refraction_angle(r1, 1, 1, n) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle([1, 1, 1], 1, 1, n) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle((1, 1, 1), 1, 1, n) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle(i, 1, 1, [0, 0, 1]) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle(i, 1, 1, (0, 0, 1)) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle(i, 1, 1, normal_ray) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle(i, 1, 1, plane=P) == Matrix([
|
||||
[ 1],
|
||||
[ 1],
|
||||
[-1]])
|
||||
assert refraction_angle(r1, 1, 1, plane=P) == \
|
||||
Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
|
||||
assert refraction_angle(r1, m1, 1.33, plane=P) == \
|
||||
Ray3D(Point3D(0, 0, 0), Point3D(Rational(100, 133), Rational(100, 133), -789378201649271*sqrt(3)/1000000000000000))
|
||||
assert refraction_angle(r1, 1, m2, plane=P) == \
|
||||
Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
|
||||
assert refraction_angle(r1, n1, n2, plane=P) == \
|
||||
Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
|
||||
assert refraction_angle(r1, 1.33, 1, plane=P) == 0 # TIR
|
||||
assert refraction_angle(r1, 1, 1, normal_ray) == \
|
||||
Ray3D(Point3D(0, 0, 0), direction_ratio=[1, 1, -1])
|
||||
assert ae(refraction_angle(0.5, 1, 2), 0.24207, 5)
|
||||
assert ae(refraction_angle(0.5, 2, 1), 1.28293, 5)
|
||||
raises(ValueError, lambda: refraction_angle(r1, m1, m2, normal_ray, P))
|
||||
raises(TypeError, lambda: refraction_angle(m1, m1, m2)) # can add other values for arg[0]
|
||||
raises(TypeError, lambda: refraction_angle(r1, m1, m2, None, i))
|
||||
raises(TypeError, lambda: refraction_angle(r1, m1, m2, m2))
|
||||
|
||||
|
||||
def test_fresnel_coefficients():
|
||||
assert all(ae(i, j, 5) for i, j in zip(
|
||||
fresnel_coefficients(0.5, 1, 1.33),
|
||||
[0.11163, -0.17138, 0.83581, 0.82862]))
|
||||
assert all(ae(i, j, 5) for i, j in zip(
|
||||
fresnel_coefficients(0.5, 1.33, 1),
|
||||
[-0.07726, 0.20482, 1.22724, 1.20482]))
|
||||
m1 = Medium('m1')
|
||||
m2 = Medium('m2', n=2)
|
||||
assert all(ae(i, j, 5) for i, j in zip(
|
||||
fresnel_coefficients(0.3, m1, m2),
|
||||
[0.31784, -0.34865, 0.65892, 0.65135]))
|
||||
ans = [[-0.23563, -0.97184], [0.81648, -0.57738]]
|
||||
got = fresnel_coefficients(0.6, m2, m1)
|
||||
for i, j in zip(got, ans):
|
||||
for a, b in zip(i.as_real_imag(), j):
|
||||
assert ae(a, b, 5)
|
||||
|
||||
|
||||
def test_deviation():
|
||||
n1, n2 = symbols('n1, n2')
|
||||
r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
|
||||
n = Matrix([0, 0, 1])
|
||||
i = Matrix([-1, -1, -1])
|
||||
normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
|
||||
P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
|
||||
assert deviation(r1, 1, 1, normal=n) == 0
|
||||
assert deviation(r1, 1, 1, plane=P) == 0
|
||||
assert deviation(r1, 1, 1.1, plane=P).evalf(3) + 0.119 < 1e-3
|
||||
assert deviation(i, 1, 1.1, normal=normal_ray).evalf(3) + 0.119 < 1e-3
|
||||
assert deviation(r1, 1.33, 1, plane=P) is None # TIR
|
||||
assert deviation(r1, 1, 1, normal=[0, 0, 1]) == 0
|
||||
assert deviation([-1, -1, -1], 1, 1, normal=[0, 0, 1]) == 0
|
||||
assert ae(deviation(0.5, 1, 2), -0.25793, 5)
|
||||
assert ae(deviation(0.5, 2, 1), 0.78293, 5)
|
||||
|
||||
|
||||
def test_brewster_angle():
|
||||
m1 = Medium('m1', n=1)
|
||||
m2 = Medium('m2', n=1.33)
|
||||
assert ae(brewster_angle(m1, m2), 0.93, 2)
|
||||
m1 = Medium('m1', permittivity=e0, n=1)
|
||||
m2 = Medium('m2', permittivity=e0, n=1.33)
|
||||
assert ae(brewster_angle(m1, m2), 0.93, 2)
|
||||
assert ae(brewster_angle(1, 1.33), 0.93, 2)
|
||||
|
||||
|
||||
def test_critical_angle():
|
||||
m1 = Medium('m1', n=1)
|
||||
m2 = Medium('m2', n=1.33)
|
||||
assert ae(critical_angle(m2, m1), 0.85, 2)
|
||||
|
||||
|
||||
def test_lens_makers_formula():
|
||||
n1, n2 = symbols('n1, n2')
|
||||
m1 = Medium('m1', permittivity=e0, n=1)
|
||||
m2 = Medium('m2', permittivity=e0, n=1.33)
|
||||
assert lens_makers_formula(n1, n2, 10, -10) == 5.0*n2/(n1 - n2)
|
||||
assert ae(lens_makers_formula(m1, m2, 10, -10), -20.15, 2)
|
||||
assert ae(lens_makers_formula(1.33, 1, 10, -10), 15.15, 2)
|
||||
|
||||
|
||||
def test_mirror_formula():
|
||||
u, v, f = symbols('u, v, f')
|
||||
assert mirror_formula(focal_length=f, u=u) == f*u/(-f + u)
|
||||
assert mirror_formula(focal_length=f, v=v) == f*v/(-f + v)
|
||||
assert mirror_formula(u=u, v=v) == u*v/(u + v)
|
||||
assert mirror_formula(u=oo, v=v) == v
|
||||
assert mirror_formula(u=oo, v=oo) is oo
|
||||
assert mirror_formula(focal_length=oo, u=u) == -u
|
||||
assert mirror_formula(u=u, v=oo) == u
|
||||
assert mirror_formula(focal_length=oo, v=oo) is oo
|
||||
assert mirror_formula(focal_length=f, v=oo) == f
|
||||
assert mirror_formula(focal_length=oo, v=v) == -v
|
||||
assert mirror_formula(focal_length=oo, u=oo) is oo
|
||||
assert mirror_formula(focal_length=f, u=oo) == f
|
||||
assert mirror_formula(focal_length=oo, u=u) == -u
|
||||
raises(ValueError, lambda: mirror_formula(focal_length=f, u=u, v=v))
|
||||
|
||||
|
||||
def test_lens_formula():
|
||||
u, v, f = symbols('u, v, f')
|
||||
assert lens_formula(focal_length=f, u=u) == f*u/(f + u)
|
||||
assert lens_formula(focal_length=f, v=v) == f*v/(f - v)
|
||||
assert lens_formula(u=u, v=v) == u*v/(u - v)
|
||||
assert lens_formula(u=oo, v=v) == v
|
||||
assert lens_formula(u=oo, v=oo) is oo
|
||||
assert lens_formula(focal_length=oo, u=u) == u
|
||||
assert lens_formula(u=u, v=oo) == -u
|
||||
assert lens_formula(focal_length=oo, v=oo) is -oo
|
||||
assert lens_formula(focal_length=oo, v=v) == v
|
||||
assert lens_formula(focal_length=f, v=oo) == -f
|
||||
assert lens_formula(focal_length=oo, u=oo) is oo
|
||||
assert lens_formula(focal_length=oo, u=u) == u
|
||||
assert lens_formula(focal_length=f, u=oo) == f
|
||||
raises(ValueError, lambda: lens_formula(focal_length=f, u=u, v=v))
|
||||
|
||||
|
||||
def test_hyperfocal_distance():
|
||||
f, N, c = symbols('f, N, c')
|
||||
assert hyperfocal_distance(f=f, N=N, c=c) == f**2/(N*c)
|
||||
assert ae(hyperfocal_distance(f=0.5, N=8, c=0.0033), 9.47, 2)
|
||||
|
||||
|
||||
def test_transverse_magnification():
|
||||
si, so = symbols('si, so')
|
||||
assert transverse_magnification(si, so) == -si/so
|
||||
assert transverse_magnification(30, 15) == -2
|
||||
|
||||
|
||||
def test_lens_makers_formula_thick_lens():
|
||||
n1, n2 = symbols('n1, n2')
|
||||
m1 = Medium('m1', permittivity=e0, n=1)
|
||||
m2 = Medium('m2', permittivity=e0, n=1.33)
|
||||
assert ae(lens_makers_formula(m1, m2, 10, -10, d=1), -19.82, 2)
|
||||
assert lens_makers_formula(n1, n2, 1, -1, d=0.1) == n2/((2.0 - (0.1*n1 - 0.1*n2)/n1)*(n1 - n2))
|
||||
|
||||
|
||||
def test_lens_makers_formula_plano_lens():
|
||||
n1, n2 = symbols('n1, n2')
|
||||
m1 = Medium('m1', permittivity=e0, n=1)
|
||||
m2 = Medium('m2', permittivity=e0, n=1.33)
|
||||
assert ae(lens_makers_formula(m1, m2, 10, oo), -40.30, 2)
|
||||
assert lens_makers_formula(n1, n2, 10, oo) == 10.0*n2/(n1 - n2)
|
||||
@@ -0,0 +1,82 @@
|
||||
from sympy.core.function import (Derivative, Function)
|
||||
from sympy.core.numbers import (I, pi)
|
||||
from sympy.core.symbol import (Symbol, symbols)
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (atan2, cos, sin)
|
||||
from sympy.simplify.simplify import simplify
|
||||
from sympy.abc import epsilon, mu
|
||||
from sympy.functions.elementary.exponential import exp
|
||||
from sympy.physics.units import speed_of_light, m, s
|
||||
from sympy.physics.optics import TWave
|
||||
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
c = speed_of_light.convert_to(m/s)
|
||||
|
||||
def test_twave():
|
||||
A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f')
|
||||
n = Symbol('n') # Refractive index
|
||||
t = Symbol('t') # Time
|
||||
x = Symbol('x') # Spatial variable
|
||||
E = Function('E')
|
||||
w1 = TWave(A1, f, phi1)
|
||||
w2 = TWave(A2, f, phi2)
|
||||
assert w1.amplitude == A1
|
||||
assert w1.frequency == f
|
||||
assert w1.phase == phi1
|
||||
assert w1.wavelength == c/(f*n)
|
||||
assert w1.time_period == 1/f
|
||||
assert w1.angular_velocity == 2*pi*f
|
||||
assert w1.wavenumber == 2*pi*f*n/c
|
||||
assert w1.speed == c/n
|
||||
|
||||
w3 = w1 + w2
|
||||
assert w3.amplitude == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2)
|
||||
assert w3.frequency == f
|
||||
assert w3.phase == atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2))
|
||||
assert w3.wavelength == c/(f*n)
|
||||
assert w3.time_period == 1/f
|
||||
assert w3.angular_velocity == 2*pi*f
|
||||
assert w3.wavenumber == 2*pi*f*n/c
|
||||
assert w3.speed == c/n
|
||||
assert simplify(w3.rewrite(sin) - w2.rewrite(sin) - w1.rewrite(sin)) == 0
|
||||
assert w3.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
|
||||
assert w3.rewrite(cos) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
|
||||
+ A2**2)*cos(pi*f*n*x*s/(149896229*m) - 2*pi*f*t + atan2(A1*sin(phi1)
|
||||
+ A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)))
|
||||
assert w3.rewrite(exp) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
|
||||
+ A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1)
|
||||
+ A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
|
||||
|
||||
w4 = TWave(A1, None, 0, 1/f)
|
||||
assert w4.frequency == f
|
||||
|
||||
w5 = w1 - w2
|
||||
assert w5.amplitude == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2) + A2**2)
|
||||
assert w5.frequency == f
|
||||
assert w5.phase == atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1) - A2*cos(phi2))
|
||||
assert w5.wavelength == c/(f*n)
|
||||
assert w5.time_period == 1/f
|
||||
assert w5.angular_velocity == 2*pi*f
|
||||
assert w5.wavenumber == 2*pi*f*n/c
|
||||
assert w5.speed == c/n
|
||||
assert simplify(w5.rewrite(sin) - w1.rewrite(sin) + w2.rewrite(sin)) == 0
|
||||
assert w5.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
|
||||
assert w5.rewrite(cos) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
|
||||
+ A2**2)*cos(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
|
||||
- A2*cos(phi2)) + pi*s*f*n*x/(149896229*m))
|
||||
assert w5.rewrite(exp) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
|
||||
+ A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
|
||||
- A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
|
||||
|
||||
w6 = 2*w1
|
||||
assert w6.amplitude == 2*A1
|
||||
assert w6.frequency == f
|
||||
assert w6.phase == phi1
|
||||
w7 = -w6
|
||||
assert w7.amplitude == -2*A1
|
||||
assert w7.frequency == f
|
||||
assert w7.phase == phi1
|
||||
|
||||
raises(ValueError, lambda:TWave(A1))
|
||||
raises(ValueError, lambda:TWave(A1, f, phi1, t))
|
||||
Reference in New Issue
Block a user