5. Other procedures to generate XY masks

[1]:

from diffractio import sp, nm, plt, np, mm, degrees, um
from diffractio.scalar_fields_XY import Scalar_field_XY
from diffractio.scalar_sources_XY import Scalar_source_XY
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.utils_drawing import draw_several_fields

5.1. Adding masks

[2]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

t1 = Scalar_mask_XY(x, y, wavelength)
t1.square(r0=(-50 * um, 0 * um), size=(50 * um, 50 * um), angle=0 * degrees)

t2 = Scalar_mask_XY(x, y, wavelength)
t2.circle(r0=(50 * um, 0 * um), radius=(25 * um, 25 * um), angle=0 * degrees)

t3 = t2 + t1

draw_several_fields([t1, t2, t3], titles=['1', '2', '1+2'])

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_3_0.png

[3]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

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

t2 = Scalar_mask_XY(x, y, wavelength)
t2.circle(r0=(80 * um, 0 * um), radius=(40 * um, 40 * um), angle=0 * degrees)

t3 = Scalar_mask_XY(x, y, wavelength)
t3.circle(r0=(-80 * um, 0 * um), radius=(40 * um, 40 * um), angle=0 * degrees)

t4 = t2.add(t1, 'maximum1')
t5 = t4.add(t3, 'maximum1')
t5.draw(title='add')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_4_0.png

5.2. Substracting masks

[4]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

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

t2 = Scalar_mask_XY(x, y, wavelength)
t2.circle(r0=(0 * um, 0 * um), radius=(45 * um, 45 * um), angle=0 * degrees)

t3 = t2 - t1
t3.draw(title='substraction')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_6_0.png

5.3. Binarization of a previous mask

[5]:

num_data = 512
length = 25 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

t1 = Scalar_mask_XY(x, y, wavelength)
t1.gray_scale(num_levels=32, levelMin=0, levelMax=1)
t1.draw(kind='intensity', has_colorbar='vertical')
plt.title('(0,1)-no binarized')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_8_0.png

[6]:

t1.binarize(kind='amplitude',
            bin_level=None,
            level0=0.25,
            level1=.75,
            new_field=False,
            matrix=False)
t1.draw(kind='intensity', has_colorbar='vertical')
plt.suptitle('binarized')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_9_0.png

5.4. Widen the shape of a previous mask

[7]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

t1 = Scalar_mask_XY(x, y, wavelength)
t1.ring(r0=(0 * um, 0 * um),
        radius1=(50 * um, 50 * um),
        radius2=(60 * um, 60 * um),
        angle=45 * degrees)

t2 = t1.widen(radius=25 * um, new_field=True, binarize=True)

draw_several_fields((t1, t2), titles=('initial', 'widened'))

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_11_0.png

5.5. Mask from surface functions

[8]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

t1 = Scalar_mask_XY(x, y, wavelength)
t1.mask_from_function(r0=(0 * um, 0 * um),
                      index=1.5,
                      f1='1*degrees*self.Y',
                      f2='1*degrees*self.X',
                      v_globals=None,
                      radius=(100 * um, 100 * um))
t1.draw(kind='field')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_13_0.png

[9]:

num_data = 512
length = 250 * um
x = np.linspace(-length / 2, length / 2, num_data)
y = np.linspace(-length / 2, length / 2, num_data)
wavelength = 0.6328 * um

f1 = "np.zeros_like(self.X,dtype=float)"
f2 = "R2-h2+np.sqrt(R2**2-(self.X-x0)**2-(self.Y-y0)**2)"
v_globals = {
    'R1': 5 * mm,
    'R2': 1 * mm,
    'x0': 0 * um,
    'y0': 0 * um,
    'h1': 1 * mm,
    'h2': -1 * mm,
    'np': np,
}
index = 1.5

t1 = Scalar_mask_XY(x, y, wavelength)
t1.mask_from_function(r0=(0 * um, 0 * um),
                      index=index,
                      f1=f1,
                      f2=f2,
                      v_globals=v_globals,
                      radius=(100 * um, 100 * um))
t1.draw(kind='field')

focal = v_globals['R2'] / (index - 1)

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_14_0.png

5.6. Insert_array_masks

The mask is repited in x-y axis separated a certain distance

[10]:

x = np.linspace(-250 * um, 250 * um, 512)
y = np.linspace(-250 * um, 250 * um, 512)
wavelength = 1 * um

s = Scalar_mask_XY(x, y, wavelength)
s.cross(r0=(0 * um, 0 * um), size=(90 * um, 25 * um), angle=0 * degrees)
s.draw()

t1 = Scalar_mask_XY(x, y, wavelength)
num_points = t1.insert_array_masks(t1=s,
                                   space=[100 * um, 100 * um],
                                   margin=50 * um,
                                   angle=90 * degrees)
t1.draw(kind='intensity')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_16_0.png

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_16_1.png

[11]:

print(s)

Scalar_mask_XY
 - x:  (512,),   y:  (512,),   u:  (512, 512)
 - xmin:       -250.00 um,  xmax:      250.00 um,  Dx:   0.98 um
 - ymin:       -250.00 um,  ymax:      250.00 um,  Dy:   0.98 um
 - Imin:       0.00,     Imax:      1.00
 - phase_min:  0.00 deg, phase_max: 0.00 deg
 - wavelength: 1.00 um
 - date:       2023-10-07_17_07_43

[12]:

print(t1)

Scalar_mask_XY
 - x:  (512,),   y:  (512,),   u:  (512, 512)
 - xmin:       -250.00 um,  xmax:      250.00 um,  Dx:   0.98 um
 - ymin:       -250.00 um,  ymax:      250.00 um,  Dy:   0.98 um
 - Imin:       0.00,     Imax:      1.00
 - phase_min:  0.00 deg, phase_max: 180.00 deg
 - wavelength: 1.00 um
 - date:       2023-10-07_17_07_43

5.7. repeat_structure

The mask si repeated (n,m) times. The size of the new mask is (n,m) times greater.

[13]:

size = 250 * um
x0 = np.linspace(-size / 2, size / 2, 512)
y0 = np.linspace(-size / 2, size / 2, 512)

wavelength = 0.6328 * um

focal = 4 * mm
lenslet = Scalar_mask_XY(x=x0, y=y0, wavelength=wavelength)
lenslet.lens(r0=(0, 0), radius=size / 2, focal=focal)
lenslet.draw('phase')

lens_array = lenslet.repeat_structure(num_repetitions=(4, 4),
                                      position='center',
                                      new_field=True)
lens_array.draw('phase')

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_20_0.png

../../../_images/source_tutorial_scalar_XY_masks_xy_procedures_20_1.png

[14]:

print(lenslet)

Scalar_mask_XY
 - x:  (512,),   y:  (512,),   u:  (512, 512)
 - xmin:       -125.00 um,  xmax:      125.00 um,  Dx:   0.49 um
 - ymin:       -125.00 um,  ymax:      125.00 um,  Dy:   0.49 um
 - Imin:       0.00,     Imax:      1.00
 - phase_min:  -179.99 deg, phase_max: 180.00 deg
 - wavelength: 0.63 um
 - date:       2023-10-07_17_07_43

[15]:

print(lens_array)

Scalar_mask_XY
 - x:  (2048,),   y:  (2048,),   u:  (2048, 2048)
 - xmin:       -500.00 um,  xmax:      500.00 um,  Dx:   0.49 um
 - ymin:       -500.00 um,  ymax:      500.00 um,  Dy:   0.49 um
 - Imin:       0.00,     Imax:      1.00
 - phase_min:  -179.99 deg, phase_max: 180.00 deg
 - wavelength: 0.63 um
 - date:       2023-10-07_17_07_44