6.3.5. Other procedures to generate XY masks

[1]:

from diffractio import plt, np, mm, degrees, um
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.utils_drawing import draw_several_fields

6.3.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_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, "mask")
t5 = t4.add(t3, "mask")
t5.draw(title="add")

/home/luismiguel/bitbucket/diffractio/diffractio/utils_common.py:304: ComplexWarning: Casting complex values to real discards the imaginary part
  t.u[i_change]=np.exp(1j*f1[i_change])+np.exp(1j*f2[i_change])

../../../_images/source_tutorial_scalar_scalar_XY_masks_xy_procedures_4_1.png

6.3.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_scalar_XY_masks_xy_procedures_6_0.png

6.3.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, level_min=0, level_max=1)
t1.draw(kind="intensity", has_colorbar="vertical")
plt.title("(0,1)-no binarized")

../../../_images/source_tutorial_scalar_scalar_XY_masks_xy_procedures_8_0.png

[6]:

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

../../../_images/source_tutorial_scalar_scalar_XY_masks_xy_procedures_9_0.png

6.3.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_scalar_XY_masks_xy_procedures_11_0.png

6.3.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_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_scalar_XY_masks_xy_procedures_14_0.png

6.3.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_scalar_XY_masks_xy_procedures_16_0.png

../../../_images/source_tutorial_scalar_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:       2024-10-21_19_25_05

[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:       2024-10-21_19_25_05

6.3.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 * um, 0 * um), 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_scalar_XY_masks_xy_procedures_20_0.png

../../../_images/source_tutorial_scalar_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.93 deg, phase_max: 180.00 deg
 - wavelength: 0.63 um
 - date:       2024-10-21_19_25_06

[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.93 deg, phase_max: 180.00 deg
 - wavelength: 0.63 um
 - date:       2024-10-21_19_25_06