7. Example of masks

7.1. Creating an instance

An instance must be created before starting to operate with vector masks. The initialization accepts several arguments.

[1]:

from diffractio import np, plt, sp
from diffractio import degrees, mm, um
from diffractio.scalar_fields_XY import Scalar_field_XY
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.scalar_sources_XY import Scalar_source_XY
from diffractio.utils_tests import save_figure_test
from diffractio.vector_fields_XY import Vector_field_XY
from diffractio.vector_masks_XY import Vector_mask_XY
from diffractio.vector_sources_XY import Vector_source_XY

from py_pol.jones_matrix import Jones_matrix

7.2. Polarization from standard elements

7.2.1. Using defined polarizers

There are several standard polarizers: - polarized_linear - quarter_waveplate - half_waveplate - polarizer_retarder

[2]:

x0 = np.linspace(-125 * um, 125 * um, 512)
y0 = np.linspace(-125 * um, 125 * um, 512)
wavelength = 0.6328 * um

# mask vectorial
vc = Vector_mask_XY(x0, y0, wavelength)
vc.polarizer_linear(azimuth=22.5 * degrees)
vc.draw(kind='amplitudes')

<Figure size 432x288 with 0 Axes>

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_5_1.png

7.2.2. Using py_pol module

If more general polarizer is required, we han use py_pol module

[3]:

x0 = np.linspace(-125 * um, 125 * um, 512)
y0 = np.linspace(-125 * um, 125 * um, 512)
wavelength = 0.6328 * um

PL = Jones_matrix('m0')
PL.from_components([0.9, 0, 0, 0.2 * np.exp(1j)])

vp = Vector_mask_XY(x0, y0, wavelength)
vp.from_py_pol(PL)

vp.draw(kind='jones_ap')

<Figure size 432x288 with 0 Axes>

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_7_1.png

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_7_2.png

7.3. Apply a mask to the polarizer

[4]:

j0 = Jones_matrix().diattenuator_perfect(azimuth=-45*degrees)

[5]:

x0 = np.linspace(-125 * um, 125 * um, 512)
y0 = np.linspace(-125 * um, 125 * um, 512)
wavelength = 0.6328 * um

mask = Scalar_mask_XY(x=x0, y=y0, wavelength=wavelength)
mask.square(r0=(0 * um, 0 * um), size=(100 * um, 100 * um), angle=0 * degrees)

# mask vectorial
vc = Vector_mask_XY(x0, y0, wavelength)
vc.scalar_to_vector_mask(mask=mask, state=j0)
vc.draw(kind='jones_ap')

<Figure size 432x288 with 0 Axes>

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_10_1.png

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_10_2.png

7.4. circle

Since normally a circular mask is used, a function for this is defined. Therefore, an Scalar_XY mask is not required.

[6]:

x0 = np.linspace(-125 * um, 125 * um, 512)
y0 = np.linspace(-125 * um, 125 * um, 512)
wavelength = 0.6328 * um

# mask vectorial
vc = Vector_mask_XY(x0, y0, wavelength)
vc.polarizer_linear(azimuth=22.5 * degrees)
vc.apply_circle()
vc.draw(kind='amplitudes')

<Figure size 432x288 with 0 Axes>

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_12_1.png

7.5. Complementary mask

When we provide a binary mask, the 1 mask is converted to v1 polarization and 0 mask is converted to v2 polarization.

[7]:

x0 = np.linspace(-125 * um, 125 * um, 512)
y0 = np.linspace(-125 * um, 125 * um, 512)
wavelength = 0.6328 * um

mask = Scalar_mask_XY(x=x0, y=y0, wavelength=wavelength)
mask.fresnel_lens(r0=(0 * um, 0 * um),
                  radius=(125 * um, 125 * um),
                  focal=(2 * mm, 2 * mm),
                  angle=0 * degrees,
                  kind='amplitudes')
mask.pupil()

EM0 = Vector_mask_XY(x0, y0, wavelength)
EM0.complementary_masks(mask=mask,
                        state_0=np.array([[1, 0], [0, 0]]),
                        state_1=np.array([[0, 0], [0, 1j]]))
EM0.draw(kind='jones_ap')

<Figure size 432x288 with 0 Axes>

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_14_1.png

../../../_images/source_tutorial_vector_XY_tutorial_vector_masks_XY_14_2.png

7.6. Pass to py_pol

[8]:

m0 = EM0.to_py_pol()