def transform(RX, RY, RZ, wavelength, period, axis, clock):
angle = np.arcsin(wavelength / period)
vec = np.array([complex(RX[2, 1]),
complex(RY[2, 1]),
complex(RZ[2, 1])],
dtype='complex')
print(f"before transform {vec}\n")
if axis is 'x':
if clock:
angle = 2 * np.pi - angle
mat = np.array([
1, 0, 0, 0,
np.cos(angle), -1 * np.sin(angle), 0,
np.sin(angle),
np.cos(angle)
])
mat = mat.reshape(3, 3)
jones = np.dot(mat, vec)
print(f"the Jones vector: {jones}\n")
Ex = complex(str(jones[0]))
Ey = complex(str(jones[1]))
j0 = Jones_vector('jones')
j0.from_components(np.array([Ex]), np.array([Ey]))
s0 = Stokes('stoked')
s0.from_Jones(j0)
check = s0.checks.is_physical()
print(f"Is the result physically viable?: {check}\n")
return s0
def calculate_final_jones_vector(j_matrix_stack, selected_frequency_index):
# Jones matrix at selected frequency for the wp stack
J_one_freq = Jones_matrix('stack')
J_one_freq.from_matrix(j_matrix_stack[selected_frequency_index])
# initial polarization is along x-axis
x_lin_pol_jones = Jones_vector('x_pol')
x_lin_pol_jones.linear_light()
return J_one_freq * x_lin_pol_jones
def calc_polarization_degrees_j(matrix_stack):
jones_final_all = np.einsum('fjk,k->fj', matrix_stack, jones_initial)
linear_comp_lst, circular_comp_lst = [], []
for jones_final in jones_final_all:
jf = Jones_vector()
jf.from_matrix(jones_final)
linear_comp_lst.append(jf.parameters.degree_linear_polarization())
circular_comp_lst.append(jf.parameters.degree_circular_polarization())
return linear_comp_lst, circular_comp_lst
def calc_phase_shift(j_matrix_stack):
J = Jones_matrix('stack')
J.from_matrix(j_matrix_stack)
# initial polarization is along x-axis
x_lin_pol_jones = Jones_vector('x_pol')
x_lin_pol_jones.linear_light()
J_out = J * x_lin_pol_jones
phase_shift = J_out.parameters.delay()
return phase_shift
def wave_plate_sim(az, initial_setting='linpol'):
# Incident Wave
E0 = Jones_vector("Incident Wave:")
if initial_setting == 'linpol':
E0.linear_light(intensity=1)
else:
E0.circular_light(intensity=1)
print(E0)
# QW Plate
M1 = create_Jones_matrices('Quarter Wave Plate')
M1.quarter_waveplate(az * degrees)
# Analyser
P1 = Jones_matrix('Analyser')
angles = np.linspace(0, 360 * degrees, 361) # Steps of 1 degree
P1.diattenuator_perfect(azimuth=angles)
E_final = P1 * M1 * E0
I_perfect = E_final.parameters.intensity()
return I_perfect
"""
#you need to install pyjones first from the anaconda command prompt
#pip install pyjones
from py_pol import degrees, np
from py_pol.jones_vector import Jones_vector
from py_pol.drawings import draw_ellipses_jones
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from py_pol import degrees, np
from py_pol.stokes import Stokes
from py_pol.mueller import Mueller
from py_pol.drawings import draw_poincare_sphere, draw_on_poincare
j0 = Jones_vector('j0')
j0.elliptical_light(a=1, b=2, phase=45 * degrees, angle=45 * degrees)
ax, fig = j0.draw_ellipse()
plt.savefig('ellipse_Jones_1.png')
#definition of a list Jones vectors
Jones_vectors_0 = []
j0 = Jones_vector('j0')
j0.linear_light(amplitude=1, angle=0 * degrees)
angles = np.linspace(0, 180 * degrees, 6, endpoint=False)
for i, angle in enumerate(angles):
ji = j0.rotate(angle=angle, keep=True)
#E2_pypol.from_matrix(E2)
#E1_pypol.parameters.get_all()
#E2_pypol.parameters.get_all()
#eigen_state.parameters.get_all()
#print(E1_pypol.parameters)
#print(E2_pypol.parameters)
#print(eigen_state.parameters)
#print(j_stack.shape)
#print(e_state.shape)
j_final = np.einsum('vab,vb->va', j_stack, e_state)
j_final_pypol = Jones_vector('j_final')
j_final_pypol.from_matrix(j_final)
polarizer_y = np.zeros((len(freqs), 2, 2))
polarizer_x = np.zeros((len(freqs), 2, 2))
orientations = j_final_pypol.parameters.azimuth()
for i, angle in enumerate(orientations):
r, r_inv = r_z_j(angle), r_z_j(-angle)
polarizer_y[i] = np.dot(r_inv, np.dot(y_pol_j, r))
r, r_inv = r_z_j(angle + pi / 2), r_z_j(-angle + pi / 2)
polarizer_x[i] = np.dot(r_inv, np.dot(x_pol_j, r))
x_pol_state = np.einsum('vab,vb->va', polarizer_x, j_final)
y_pol_state = np.einsum('vab,vb->va', polarizer_y, j_final)
#x_pol_state = np.einsum('ab,vb->va', x_pol_j, j_final)
import numpy as np
import matplotlib.pyplot as plt
from py_pol import degrees
from py_pol.jones_vector import Jones_vector
from py_pol.jones_matrix import Jones_matrix, create_Jones_matrices
"""
Part a)
Linear Polarizer
"""
# Incident wave
E0 = Jones_vector('Incident wave: Linear. Light')
E0.linear_light(intensity=1, azimuth=90 * degrees)
print(E0)
# analyser
P1 = Jones_matrix('Analyzer')
angles = np.linspace(0, 360 * degrees, 361) # Steps of 1 degree
P1.diattenuator_perfect(azimuth=angles)
E_final = P1 * E0
E_final.name = 'Output wave'
I_perfect = E_final.parameters.intensity()
"""
b) Circulalry polarized light
"""