1.6. Jones_vector class

Jones_Vector is a class that manages Jones vectors. It allows the user to create and manipulate them.

1.6.1. Creating an instance

An instance must be created before starting to operate with the Jones vector. The initialization accepts one argument: the name of the vector. This name will be used for printing:

[2]:
from py_pol.jones_vector import Jones_vector, create_Jones_vectors
from py_pol.utils import degrees
import numpy as np
d:\codigo_ucm\py_pol\py_pol\jones_vector.py:203: SyntaxWarning: "is" with a literal. Did you mean "=="?
  if other._type is 'Jones_vector':
d:\codigo_ucm\py_pol\py_pol\jones_vector.py:224: SyntaxWarning: "is" with a literal. Did you mean "=="?
  if other._type is 'Jones_vector':
d:\codigo_ucm\py_pol\py_pol\jones_vector.py:975: SyntaxWarning: "is not" with a literal. Did you mean "!="?
  if global_phase is not 0:
d:\codigo_ucm\py_pol\py_pol\jones_vector.py:1307: SyntaxWarning: "is not" with a literal. Did you mean "!="?
  if global_phase is not 0:
[3]:
E = Jones_vector("Source 1")
print(E)
Source 1 is empty

Several Jones_vector objects can be created at the same time using the function create_Jones_vectors.

[4]:
E1, E2 = create_Jones_vectors(name=('Source 2', 'Source 3'))
print(E1, E2)

list_of_E = create_Jones_vectors(N=3)
print(list_of_E)
Source 2 is empty
 Source 3 is empty

[E is empty
, E is empty
, E is empty
]

1.6.2. Jones_vector class fields

Jones_vector class objects have some fields where some methods and information stored:

  • M: 2xN array containing all the Jones vectors.
  • name: Name of the object for print purposes.
  • size: Number of stored Jones vectors.
  • shape: Shape desired for the outputs.
  • ndim: Number of dimensions for representation purposes.
  • **_type**: Type of the object (‘Jones_vector’). This is used for determining the object class as using isinstance may throw unexpected results in .ipynb files.
  • parameters: Object of class Parameters_Jones_vector.
  • checks: Object of class Checks_Jones_vector.
[5]:
E = Jones_vector("Source 1")
amp = np.random.rand(3,3)
E.linear_light(azimuth = 0, amplitude=amp)

print('Array: ', E.M)
print('Name: ', E.name)
print('Size: ', E.size)
print('Shape: ', E.shape)
print('Number of dimensions: ', E.ndim)
print('Type: ', E._type, '\n')

print('Parameters (intensity): \n', E.parameters.intensity(), '\n')
print('Checks (circularly polarized): \n', E.checks.is_circular(), '\n')
Array:  [[0.42489842+0.j 0.62622041+0.j 0.97220609+0.j 0.61160548+0.j
  0.94799541+0.j 0.4672298 +0.j 0.81473292+0.j 0.16008501+0.j
  0.18007924+0.j]
 [0.        +0.j 0.        +0.j 0.        +0.j 0.        +0.j
  0.        +0.j 0.        +0.j 0.        +0.j 0.        +0.j
  0.        +0.j]]
Name:  Source 1
Size:  9
Shape:  [3, 3]
Number of dimensions:  2
Type:  Jones_vector

Parameters (intensity):
 [[0.18053866 0.392152   0.94518468]
 [0.37406126 0.8986953  0.21830368]
 [0.66378973 0.02562721 0.03242853]]

Checks (circularly polarized):
 [[False False False]
 [False False False]
 [False False False]]

1.6.3. Generating polarization states

As shown in the previous example, the Jones vector is initialized with all elements equal to zero. There are many methods that can be used to generate a more desirable vector:

  • from_components: Creates a Jones_vector object directly from the electric field components \(E_x\) and \(E_y\).
  • from_matrix: Creates a Jones_vector object directly from a 2xN numpy array.
  • from_list: Creates a Jones_vector object directly from a list of 2 or 2x1 numpy arrays.
  • from_distribution: Creates a Jones vector from the temporal evolution of the electric field components.
  • from_Stokes: Creates a Jones vector from a Stokes object. Take into account that only pure (totally polarized) Stokes vectors must be transformed to Jones vectors, and thet even for them, the global phase is unknown.
  • linear_light: Creates a state of linear polarization with the desired angle.
  • circular_light: Creates a state of circular polarization.
  • eliptical_light: Creates a state of eliptical polarization.
  • general_azimuth_ellipticity: Creates a Jones vector from the azimuth, ellipticity and amplitude parameters.
  • general_charac_angles: Creates a Jones vector from the characteristic angles and amplitude parameters.

For a more detailed description of each method, refer to the individual documentation of each one.

Example:

[6]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 30*degrees, amplitude=1)
print(E)
Source 1 =
[+0.866+0.000j]
[+0.500+0.000j]

The previous example only stores one Jones vector. It is possible to store many Jones vectors in the same object. This is useful specially when the same operation is performed upon all of them, as rotation. In this way, it is not required to use for loops, reducing significantly the computation time.

There are many ways of creating several Jones vectors in the same object. The first way is creating an object with several identical vectors. This is performed using the length argument:

[7]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees, amplitude=2, length = 5)
print(E)
Source 1 =
[+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]
[+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]   [+1.414+0.000j]

A second way of creating several vectors at the same time is using an array as one of the parameters. Take into account that, if you use this option, all parameters must have the same number of elements or just one element. Otherwise, the program will throw an exception.

[8]:
E = Jones_vector("Source 1")
angles = np.linspace(0, 90*degrees, 5)
E.linear_light(azimuth = angles, amplitude=2)
print(E)
Source 1 =
[+2.000+0.000j]   [+1.848+0.000j]   [+1.414+0.000j]   [+0.765+0.000j]   [+0.000+0.000j]
[+0.000+0.000j]   [+0.765+0.000j]   [+1.414+0.000j]   [+1.848+0.000j]   [+2.000+0.000j]

If the parameters have dimension higher than 1, the program will store that information in order to make prints and plots. In that case, the print function separates the two components Jones vectors:

\[\begin{split}E=\left[\begin{array}{c} E_{x}\\ E_y \end{array}\right]\end{split}\]
[9]:
E = Jones_vector("Source 1")
amp = np.random.rand(3,3)
E.linear_light(azimuth = 0, amplitude=amp)
print(E)
Source 1 Ex =
[[0.58345592+0.j 0.34259168+0.j 0.83323172+0.j]
 [0.04041141+0.j 0.42440684+0.j 0.84811839+0.j]
 [0.71128329+0.j 0.08263032+0.j 0.9582417 +0.j]]
Source 1 Ey =
[[0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j]]

1.6.3.1. Features of creation methods

py_pol model sets the origin of phase in \(E_x\). It means that the parameter global_phase of most creation methods and the methods remove_global_phase and set_global_phase (see below) will take it as the reference.

[10]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees, global_phase=90*degrees)
print(E)

E.remove_global_phase()
print(E)
Source 1 =
[+0.000+0.707j]
[+0.000+0.707j]

Source 1 =
[+0.707+0.000j]
[+0.707+0.000j]

All creation methods that accepts an amplitude or an intensity parameter (\(a\) and \(b\) for elliptical_light) in order to set the electric field amplitude (the norm of the electric field vector) or the intensity. If both of them are given together to the method, it will use the amplitude:

[11]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees, amplitude=5)
print(E)
_ = E.parameters.intensity(verbose=True)

E = Jones_vector("Source 2")
E.linear_light(azimuth = 45*degrees, intensity=2)
print(E)
_ = E.parameters.intensity(verbose=True)

E = Jones_vector("Source 3")
E.linear_light(azimuth = 45*degrees, intensity=2, amplitude=5)
print(E)
_ = E.parameters.intensity(verbose=True)
Source 1 =
[+3.536+0.000j]
[+3.536+0.000j]

The intensity of Source 1 is (a.u.):
25.0

Source 2 =
[+1.000+0.000j]
[+1.000+0.000j]

The intensity of Source 2 is (a.u.):
2.000000000000001

Source 3 =
[+3.536+0.000j]
[+3.536+0.000j]

The intensity of Source 3 is (a.u.):
25.0

1.6.4. Basic operations

Some physical phenomena that affects polarized light is described by simple operations performed to their Jones vectors.

1.6.4.1. Addition of two Jones vectors

The interference of two light waves can be represented by the sum of their Jones vectors.

[12]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 0*degrees, amplitude=1)
print(E1)
E2 = Jones_vector("Source 2")
E2.linear_light(azimuth = 45*degrees, amplitude=1, global_phase = 45*degrees)
print(E2)
E3 = E1 + E2
print(E3)
Source 1 =
[+1.000+0.000j]
[+0.000+0.000j]

Source 2 =
[+0.500+0.500j]
[+0.500+0.500j]

Source 1 + Source 2 =
[+1.500+0.500j]
[+0.500+0.500j]

1.6.4.2. Multiply by a constant

The absorption and gain experienced by a light wave is described by multiplying its Jones vector by a real positive number \(c\). The light wave will experience absorption if \(c<0\) and gain if \(c>0\):

[13]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 0*degrees, amplitude = 0.5)
print(E1)

E2 = 2 * E1
print(E2)

E2 =  E1*3
print(E2)

E2 =  E1/3
print(E2)
Source 1 =
[+0.500+0.000j]
[+0.000+0.000j]

Source 1 * 2 =
[+1.000+0.000j]
[+0.000+0.000j]

Source 1 * 3 =
[+1.500+0.000j]
[+0.000+0.000j]

Source 1 / 3 =
[+0.167+0.000j]
[+0.000+0.000j]

If the constant is complex, the constant phase will be added to the global phase of the light, while its absolute value will increase or decrease the electric field amplitude.

Take into account that real negative values are a special case of complex numbers whose phase is 180º.

[14]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 0*degrees, amplitude = 0.5)
print(E1)

c = 0.5-0.5j
E2 = c * E1
print(E2)

c = 1j
E2 = c * E1
print(E2)
Source 1 =
[+0.500+0.000j]
[+0.000+0.000j]

Source 1 * (0.5-0.5j) =
[+0.250-0.250j]
[+0.000+0.000j]

Source 1 * 1j =
[+0.000+0.500j]
[+0.000+0.000j]

1.6.4.3. Equality

It is possible to compare two Jones_vector objects and tell if they are the same. It just compares electric field, not the rest of object fields.

[15]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 0*degrees)
print(E1)
E2 = Jones_vector("Source 2")
E2.linear_light(azimuth = 0.01*degrees)
print(E2)

print('Comparison: ', E1==E2)
Source 1 =
[+1.000+0.000j]
[+0.000+0.000j]

Source 2 =
[+1.000+0.000j]
[+0.000+0.000j]

Comparison:  False

1.6.4.4. Operations and multidimensionality

The basic operations of Jones_vector objects are subject to the same casting rules as numpy arrays. This means that they can be easily used even if one or both elements of the operation have more than one element.

Here are some examples:

[16]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 0*degrees, amplitude=1)
print(E1)
E2 = Jones_vector("Source 2")
angles = np.linspace(0, 90*degrees, 5)
E2.linear_light(azimuth = angles, amplitude=1, global_phase = 45*degrees)
print(E2)

E3 = E1 + E2
print(E3)
Source 1 =
[+1.000+0.000j]
[+0.000+0.000j]

Source 2 =
[+0.707+0.707j]   [+0.653+0.653j]   [+0.500+0.500j]   [+0.271+0.271j]   [+0.000+0.000j]
[+0.000+0.000j]   [+0.271+0.271j]   [+0.500+0.500j]   [+0.653+0.653j]   [+0.707+0.707j]

Source 1 + Source 2 =
[+1.707+0.707j]   [+1.653+0.653j]   [+1.500+0.500j]   [+1.271+0.271j]   [+1.000+0.000j]
[+0.000+0.000j]   [+0.271+0.271j]   [+0.500+0.500j]   [+0.653+0.653j]   [+0.707+0.707j]

[17]:
E1 = Jones_vector("Source 1")
E1.linear_light(azimuth = 30*degrees, amplitude = 1)
print(E1)

c = np.linspace(0.1, 2.3, 5)
E2 = c * E1
print(E2)
Source 1 =
[+0.866+0.000j]
[+0.500+0.000j]

E =
[+0.087+0.000j]   [+0.563+0.000j]   [+1.039+0.000j]   [+1.516+0.000j]   [+1.992+0.000j]
[+0.050+0.000j]   [+0.325+0.000j]   [+0.600+0.000j]   [+0.875+0.000j]   [+1.150+0.000j]

[18]:
E1 = Jones_vector("Source 1")
angles = np.linspace(0, 90*degrees, 5)
E1.linear_light(azimuth = 90*degrees + angles, amplitude=1)
print(E1)
E2 = Jones_vector("Source 2")
E2.linear_light(azimuth = angles, amplitude=1, global_phase = 45*degrees)
print(E2)

E3 = E1 - E2
print(E3)
Source 1 =
[+0.000+0.000j]   [-0.383+0.000j]   [-0.707+0.000j]   [-0.924+0.000j]   [-1.000+0.000j]
[+1.000+0.000j]   [+0.924+0.000j]   [+0.707+0.000j]   [+0.383+0.000j]   [+0.000+0.000j]

Source 2 =
[+0.707+0.707j]   [+0.653+0.653j]   [+0.500+0.500j]   [+0.271+0.271j]   [+0.000+0.000j]
[+0.000+0.000j]   [+0.271+0.271j]   [+0.500+0.500j]   [+0.653+0.653j]   [+0.707+0.707j]

Source 1 - Source 2 =
[-0.707-0.707j]   [-1.036-0.653j]   [-1.207-0.500j]   [-1.194-0.271j]   [-1.000-0.000j]
[+1.000+0.000j]   [+0.653-0.271j]   [+0.207-0.500j]   [-0.271-0.653j]   [-0.707-0.707j]

1.6.5. Jones vector manipulation

There are several operations that can be applied to a Jones vector.

  • get: Gets a matrix with the electric field components.
  • clear: Removes data and name form Jones vector.
  • copy: Creates a copy of the Jones_vector object.
  • stretch: Stretches a Jones vector of size 1.
  • shape_like: Takes the shape of another object to use as its own.
  • simplify: Simplifies the Jones vector in several ways.
  • rotate: Rotates the Jones vector.
  • sum: Calculates the summatory of the Jones vectors in the object.
  • flip: Flips the object along some dimensions.
  • reciprocal: Calculates the Jones vector that propagates backwards.
  • orthogonal: Calculates the orthogonal Jones vector.
  • normalize: Normalize the electric field to be normalized in electric field amplitude or intensity.
  • rotate_to_azimuth: Rotates the Jones vector to have a certain azimuth.
  • remove_global_phase: Calculates the global phase of the electric field (respect to the X component) and removes it.
  • add_global_phase: Adds a global phase to the Jones vector.
  • set_global_phase: Sets the global phase of the Jones vector.
  • add_delay: Adds a phase to the Y component of the electric field of the Jones vector.
  • draw_ellipse: Draws the polarization ellipse of the Jones vector.

All the functions return the Jones_vector object. For a more detailed description of each method, refer to the individual documentation of each one.

Example:

[19]:
E1 = Jones_vector('Source 1')
E1.linear_light(azimuth=0*degrees)
print(E1)

E1.rotate(angle=45*degrees)
print(E1)
Source 1 =
[+1.000+0.000j]
[+0.000+0.000j]

Source 1 @ 45.00 deg =
[+0.707+0.000j]
[+0.707+0.000j]

All manipulation methods have the keep argument that specifies if the originial object must be preserved or transformed. If keep is True (default is False), a new object is created:

[20]:
E1 = Jones_vector('Source 1')
E1.linear_light(azimuth=0*degrees)

E2 = E1.rotate(angle=45*degrees, keep=True)
E2.name = 'Source 2'
print(E1, E2)

E2 = E1.rotate(angle=45*degrees, keep=False)
E2.name = 'Source 2'
print(E1, E2)
Source 1 =
[+1.000+0.000j]
[+0.000+0.000j]
 Source 2 =
[+0.707+0.000j]
[+0.707+0.000j]

Source 2 =
[+0.707+0.000j]
[+0.707+0.000j]
 Source 2 =
[+0.707+0.000j]
[+0.707+0.000j]

Jones_vector objects allow taking elements and changing them through indices like a numpy.ndarray.

Examples:

[21]:
M = np.random.rand(2, 3, 5)
E = Jones_vector('Original')
E.from_matrix(M)
print(E)

E2 = E[0:3]
print(E2)
Original Ex =
[[0.59846507 0.76895564 0.4976668  0.88884345 0.16612203]
 [0.00779228 0.70250326 0.48527475 0.21955637 0.03129468]
 [0.67954502 0.97966195 0.42200705 0.48249309 0.59698486]]
Original Ey =
[[0.80449835 0.3444458  0.37697052 0.61480205 0.66917071]
 [0.66473943 0.73639115 0.79999352 0.0440224  0.23428444]
 [0.7501775  0.99535776 0.54259311 0.94779494 0.51348343]]

Original_picked =
[+0.598]   [+0.769]   [+0.498]
[+0.804]   [+0.344]   [+0.377]

[22]:
E2.linear_light()
E3 = E.copy()
E3.name = 'Cambiado'
E3[0:3,0:2] = E2
print(E3)
Cambiado Ex =
[[1.        +0.j 1.        +0.j 0.4976668 +0.j 0.88884345+0.j
  0.16612203+0.j]
 [1.        +0.j 1.        +0.j 0.48527475+0.j 0.21955637+0.j
  0.03129468+0.j]
 [1.        +0.j 1.        +0.j 0.42200705+0.j 0.48249309+0.j
  0.59698486+0.j]]
Cambiado Ey =
[[0.        +0.j 0.        +0.j 0.37697052+0.j 0.61480205+0.j
  0.66917071+0.j]
 [0.        +0.j 0.        +0.j 0.79999352+0.j 0.0440224 +0.j
  0.23428444+0.j]
 [0.        +0.j 0.        +0.j 0.54259311+0.j 0.94779494+0.j
  0.51348343+0.j]]

1.7. Parameters of Jones_vector

Several parameters can be measured from a Jones vector. They are implemented in the independent class Parameters_Jones_vector, which is stored in the parameters field of Jones_vector class.

  • components: Calculates the electric field components of the Jones vector.
  • amplitudes: Calculates the electric field amplitudes of the Jones vector.
  • intensity: Calculates the intensity of the Jones vector.
  • irradiance: Calculates the irradiance of the Jones vector.
  • alpha: Calculates the ratio between electric field amplitudes (\(E_x\)/\(E_y\)).
  • delay / delta: Calculates the delay (phase shift) between Ex and Ey components of the electric field.
  • charac_angles: Calculates both alpha and delay, the characteristic angles of the Jones vector.
  • azimuth: Calculates azimuth, that is, the orientation angle of the major axis.
  • ellipticity_angle: Calculates the ellipticity angle.
  • azimuth_ellipticity: Calculates both azimuth and ellipticity angles.
  • ellipse_axes: Calculates the length of major and minor axis (a,b).
  • ellipticity_param: Calculates the ellipticity parameter, b/a.
  • eccentricity: Calculates the eccentricity, the complementary of the ellipticity parameter.
  • global_phase: Calculates the global phase of the Jones vector (respect to the X component of the electric field).
  • degree_linear_polarization: Calculates the degree of linear polarization of the Jones vector.
  • degree_circular_polarization: Calculates the degree of circular polarization of the Jones vector.
  • norm: Calculates the norm of the Jones vector.
  • get_all: Returns a dictionary with all the parameters of Jones vector.

For a more detailed description of each method, refer to the individual documentation of each one.

Example:

[23]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees)
I0 = E.parameters.intensity()
print(I0)
1.0

When several Jones vectors are stored in the object, setting verbose argument to True makes the method print the values in screen. Also, 1D or 2D figures can be shown if the draw argument is set to True:

[24]:
az = np.linspace(0, 180*degrees, 12)
E = Jones_vector("Source 1")
E.general_azimuth_ellipticity(azimuth=az)
az = E.parameters.azimuth(draw=True, verbose=True)
The azimuth of Source 1 is (deg.):
[0.00000000e+00 1.63636364e+01 3.27272727e+01 4.90909091e+01
 6.54545455e+01 8.18181818e+01 9.81818182e+01 1.14545455e+02
 1.30909091e+02 1.47272727e+02 1.63636364e+02 7.01670930e-15]
The mean value is 74.99999999999999 +- 54.46016058467961
../../_images/source_tutorial_Jones_vector_42_1.png

[25]:
az = np.linspace(0, 180*degrees, 128)
el = np.linspace(-45*degrees, 45*degrees, 128)
AZ, EL = np.meshgrid(az, el)

E = Jones_vector("Source 1")
E.general_azimuth_ellipticity(azimuth=AZ, ellipticity=EL)
AZ, EL = E.parameters.azimuth_ellipticity(draw=True)
The azimuth and ellipticity angles of Source 1 are (deg.):
The mean value of param Azimuth (deg.) is 91.25244140625 +- 52.246912162199024
The mean value of param Ellipticity angle (deg.) is 1.7763568394002505e-15 +- 26.184535918359188
../../_images/source_tutorial_Jones_vector_43_1.png

There is a method in Parameters_Jones_vector class, get_all that computes all the parameters available and stores in a dictionary .dict_params(). Using the print function upon the Parameters_Jones_vector class invokes the method get_all.

Example:

[26]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees)
print(E,'\n')
print(E.parameters)
Source 1 =
[+0.707+0.000j]
[+0.707+0.000j]


The elctric field components of Source 1 are (V/m):
  Ex (V/m)
(0.7071067811865476+0j)
  Ey (V/m)
(0.7071067811865476+0j)
Low dimensionality, figure not available.

The elctric field amplitudes of Source 1 are (V/m):
  Ex (V/m)
0.7071067811865476
  Ey (V/m)
0.7071067811865476
Low dimensionality, figure not available.

The intensity of Source 1 is (a.u.):
1.0
Low dimensionality, figure not available.

The norm of Source 1 is (a.u.):
1.0
Low dimensionality, figure not available.

The irradiance of Source 1 is (W/m^2):
0.0013272104690361798
Low dimensionality, figure not available.

The ratio angle between electric field amplitudes of Source 1 is (deg.):
45.0
Low dimensionality, figure not available.

Delay between electric field components of Source 1 is (deg.):
0.0
Low dimensionality, figure not available.

The azimuth of Source 1 is (deg.):
44.999999999999986
Low dimensionality, figure not available.

The ellipticity angle of Source 1 is (deg.):
0.0
Low dimensionality, figure not available.

The global phase of Source 1 is (deg.):
0.0
Low dimensionality, figure not available.

The ellipse axes of Source 1 are (V/m):
  a (V/m)
1.0
  b (V/m)
0.0
Low dimensionality, figure not available.

The ellipticity parameter of Source 1 is:
0.0
Low dimensionality, figure not available.

The eccentricity of Source 1 is:
1.0
Low dimensionality, figure not available.

The degree of circular polarization of Source 1 is:
-0.0
Low dimensionality, figure not available.

The degree of linear polarization of Source 1 is:
1.0
Low dimensionality, figure not available.


1.8. Checks of Jones_vector

There are several checks that can be performed upon a Jones vector. They are implemented in the independent class Checks_Jones_vector, which is stored in the checks field of Jones_vector class.

  • is_linear: Checks if the Jones vector is lienarly polarized.
  • is_circular: Checks if the Jones vector is circularly polarized.
  • is_right_handed: Checks if the Jones vector rotation direction is right handed.
  • is_left_handed: Checks if the Jones vector rotation direction is left handed.
  • get_all: Returns a dictionary with all the checks of Jones vector.

For a more detailed description of each method, refer to the individual documentation of each one.

Example:

[27]:
E = Jones_vector("Source 1")
E.linear_light(azimuth = 45*degrees)
cond = E.checks.is_linear()
print(cond)
True

1D and 2D plot draws are also implemented for this class:

[28]:
alpha = np.linspace(45*degrees, 45*degrees, 56)
delay = np.linspace(0, 360*degrees, 56)
Alpha, Delay = np.meshgrid(alpha, delay)

E = Jones_vector("Source 1")
E.general_charac_angles(alpha=Alpha, delay=Delay)
_ = E.checks.is_right_handed(draw=True)
(3136,) (3136,)
Source 1 is right handed:
The mean value is nan +- nan
../../_images/source_tutorial_Jones_vector_49_1.png

[ ]: