### Importing Diffractio modules

Source: https://github.com/optbrea/diffractio/blob/main/test_jupyter/test_Diffractio.ipynb

Initial setup for the Diffractio environment.

```python
from diffractio import np
from diffractio import um, degrees

from diffractio.diffractio import Diffractio
```

--------------------------------

### Install Diffractio from Source

Source: https://github.com/optbrea/diffractio/blob/main/docs/installation.md

After cloning the repository, use this command to install diffractio locally. The command differs slightly between Linux and Windows.

```console
# Linux:
$ python3 setup.py install
```

```console
# Windows:
$ python setup.py install
```

--------------------------------

### Set up local development environment

Source: https://github.com/optbrea/diffractio/blob/main/CONTRIBUTING.rst

Commands to create a virtual environment and install the package in development mode.

```shell
$ mkvirtualenv diffractio
$ cd diffractio/
$ python setup.py develop
```

--------------------------------

### Set up local development environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/contributing.md

Install the diffractio project locally using `setup.py develop` within a virtual environment.

```shell
mkvirtualenv diffractio
cd diffractio/
python setup.py develop
```

--------------------------------

### Initialize 2D simulation

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/algorithms/FFT.ipynb

Imports and setup for 2D scalar sources and masks.

```python
from diffractio.scalar_sources_XY import Scalar_source_XY
from diffractio.scalar_masks_XY import Scalar_mask_XY
```

```python
x0 = np.linspace(-150 * um, 150 * um, 1024)
y0 = np.linspace(-150 * um, 150 * um, 1024)
wavelength = 0.5 * um
```

--------------------------------

### Initialize 1D diffraction environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/comparison/CZT_vs_RS.ipynb

Imports and initial setup for 1D scalar diffraction simulations.

```python
from diffractio import mm, um, np, plt
from diffractio.scalar_sources_X import Scalar_source_X
from diffractio.scalar_masks_X import Scalar_mask_X
```

--------------------------------

### Define simulation parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/talbot_effect.ipynb

Setup spatial coordinates and wavelength for the simulation grid.

```python
x = np.linspace(-350 * um, 350 * um, 2048)
z = np.linspace(0 * um, 10 * mm, 512)
wavelength = 0.6238 * um
period = 40 * um
z_talbot = 2 * period**2 / wavelength
```

--------------------------------

### Load DXF file configuration

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Example setting the units for a DXF file import, where 13 corresponds to micrometers.

```python
msp.units = 13 # 0 - sin ,  4 mm,   12 nm,  13 um,
```

--------------------------------

### Initializing Optical Masks and Sources

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/multiprocessing.ipynb

Setup for Ronchi grating, lens masks, and scalar sources used in subsequent simulation steps.

```python
x = np.linspace(-500*um, 500*um, 1024 * 8)
wavelength = 0.850*um
num_fuentes = 101
S = 3000*um
z0 = -500*mm
period = 50*um
focal = 5*mm

red = Scalar_mask_X(x, wavelength)
red.ronchi_grating(x0=0*um, period=period, fill_factor=0.5)

lens = Scalar_mask_X(x, wavelength)
lens.lens(x0=0, focal=focal, radius=30*mm)

u1 = Scalar_source_X(x, wavelength)
```

--------------------------------

### Initialize Scalar Field Simulation

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/drawing/interactive_in_diffractio.ipynb

Setup of spatial coordinates, Gaussian beam source, and refractive index layer.

```python
x0 = np.linspace(-110 * um, 110 * um, 2048)
z0 = np.linspace(-110 * um, 110 * um, 2048)
wavelength = 1 * um
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.gauss_beam(A=1, x0=0 * um, z0=80 * um, w0=40 * um, theta=0 * degrees)

u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)

u1.incident_field(u0)
u1.layer(r0=(50 * um, 0 * um), depth=100 * um, refractive_index=5, angle=45 * degrees)
```

--------------------------------

### Initialize Multiprocessing Environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_X/tutorial_x.ipynb

Setup the number of processors based on the system's CPU count.

```python
from diffractio.scalar_fields_X import extended_source_multiprocessing
import multiprocessing

num_max_processors = multiprocessing.cpu_count()
```

--------------------------------

### Define Simulation Parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/algorithms/CZT.ipynb

Setup of physical dimensions, sampling grid, wavelength, and propagation distance.

```python
size = 250 * um
xin = np.linspace(-size, size, 4096)
wavelength = 550 * nm
z = 2 * mm
```

--------------------------------

### Configuring 2D XZ simulation

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_vector/algorithms/FPWPM.ipynb

Setup for a Ronchi grating simulation in the XZ plane.

```python
scale='auto'

period = 2*um
wavelength = .5 * um
z_talbot = 2*period**2/wavelength
print(z_talbot)

x0 = np.linspace(- 0, 2*period, 1024)
z0 = np.linspace(-2 * um, 1*z_talbot, 1024)

u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.plane_wave(theta = 0*degrees)

u_xz = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength, n_background=1)
u_xz.incident_field(u0)

u_xz.ronchi_grating(r0=(0*um, 0*um), period=period, fill_factor=0.5, 
                    height = 1*wavelength, refractive_index=1.5+2j, length = 32*wavelength, Dx = 0, 
                    heigth_substrate = 1*um,
                    refractive_index_substrate=1.5, angle=0)

u_xz.draw_refractive_index(scale=scale, draw_borders=False, colorbar_kind='horizontal')
```

--------------------------------

### Setup XZ Diffraction Simulation

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/arago_point.ipynb

Configure the source, mask, and compute diffraction in the XZ plane.

```python
source_x = Scalar_source_X(x0, wavelength)
source_x.gauss_beam(x0=0, w0=130 * um, z0=0, A=1, theta=0.0)
```

```python
mask_x = Scalar_mask_X(x0, wavelength)
mask_x.slit(x0=0, size=100 * um)
mask_x.u = 1 - mask_x.u
```

```python
u1 = source_x * mask_x
```

```python
arago_xz = Scalar_mask_XZ(x0, z0, wavelength)
arago_xz.incident_field(u1)
```

```python
arago_xz.RS()
```

```python
arago_xz.draw()
fig = plt.gcf()
fig.set_size_inches(8, 3)
```

--------------------------------

### Initialize far-field source and mask

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/fresnel_lens.ipynb

Setup Gaussian beam and Fresnel lens for far-field analysis.

```python
u0 = Scalar_source_X(x=x0_far, wavelength=wavelength)
u0.gauss_beam(A=1, x0=0 * um, z0=0 * um, w0=1 * mm, theta=0 * degrees)
t0 = Scalar_mask_X(x=x0_far, wavelength=wavelength)
```

--------------------------------

### Defining parameters for DXF loading

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/dxf_XZ.ipynb

Setup of spatial coordinates, wavelength, and filename for DXF processing.

```python
x = np.linspace(-.150*mm, .150*mm, 256)
z = np.linspace(0*mm, 1*mm, 512)
wavelength = 5*um

filename_dxf = './hatch_polyline2.dxf'
```

--------------------------------

### Setup and Execute Double Grating Experiment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/multiprocessing.ipynb

This script sets up the optical parameters, initializes gratings, creates a parameter dictionary, and executes the experiment using multiprocessing. It defines spatial grids, wavelengths, grating periods, and propagation distances.

```python
x0 = np.linspace(-400*um, 400*um, 1024 * 2)
wavelength = 0.85*um
period = 50*um
z_talbot = 2 * period**2 / wavelength
z0 = z_talbot/2
delay = 0.001

t1 = Scalar_mask_X(x0, wavelength, info="__experiment_grating_movement__")
t1.ronchi_grating(x0=0*um, period=period, fill_factor=0.5)
t1.RS(z=z0, new_field=False)

t2 = Scalar_mask_X(x0, wavelength, info="__experiment_grating_movement__")
t2.ronchi_grating(x0=0*um, period=period, fill_factor=0.5)

deltas_x = np.linspace(-60*um, 60*um, 128)  # 512
num_processors = 1

dict_Parameters = creation_dictionary(deltas_x=deltas_x,
                                      period=period,
                                      t1=t1,
                                      t2=t2)

u_s, time_proc = execute_multiprocessing(__experiment_grating_movement__,
                                         dict_Parameters,
                                         num_processors,
                                         verbose=True)

x = u_s[0].x
```

--------------------------------

### Initialize vector field source

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_vector/vector_XY/tutorial_vector_XY_draw.ipynb

Setup of a Gaussian beam and azimuthal wave propagation for vector field analysis.

```python
length = 500 * um
num_data = 256
wavelength = 0.6328 * um

x0 = np.linspace(-200 * um, 200 * um, 512)
y0 = np.linspace(-200 * um, 200 * um, 512)

u0 = Scalar_source_XY(x0, y0, wavelength)
u0.gauss_beam(A=1, r0=(0 * um, 0 * um), w0=100 * um, z0=0)

EM = Vector_source_XY(x0, y0, wavelength)
EM.azimuthal_wave(u=u0, r0=(0 * um, 0 * um), radius=(200, 200))
EM.VRS(z=10 * mm, new_field=False)
EM.normalize()

Exm, Eym, _ = EM.get("E")

Ex = Scalar_source_XY(x0, y0, wavelength)
Ex.u = Exm
Ey = Scalar_source_XY(x0, y0, wavelength)
Ey.u = Eym
Ez = Scalar_source_XY(x0, y0, wavelength)

EM.reduce_matrix = ""
```

--------------------------------

### Setup XYZ Field and Diffraction

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/arago_point.ipynb

Initialize the XYZ field, set the incident field, and compute the Rayleigh-Sommerfeld diffraction.

```python
u0 = Scalar_source_XY(x0, y0, wavelength)
u0.gauss_beam(r0=(0 * um, 0 * um), w0=130 * um, z0=0, A=1, theta=0.0)
```

```python
obstacle = Scalar_mask_XY(x0, y0, wavelength)
obstacle.circle(r0=(0 * um, 0 * um), radius=50 * um)
obstacle.inverse_amplitude()

u1 = u0 * obstacle
```

```python
u_xyz = Scalar_field_XYZ(x0, y0, z0, wavelength)
```

```python
u_xyz.incident_field(u1)
```

```python
u_xyz.RS(num_processors=1)
```

```python
u_xyz.draw_XZ(y0=0)
fig = plt.gcf()
fig.set_size_inches(8, 3)
```

--------------------------------

### Simulate total reflection at a layered medium

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/reflection_refraction.ipynb

This example demonstrates total reflection at a layered medium. It sets up a Gaussian beam, defines a layer with a refractive index of 1.5, and visualizes the refractive index and intensity patterns, focusing on the reflection phenomenon.

```python
x0 = np.linspace(-150 * um, 300 * um, 2048)
z0 = np.linspace(-150 * um, 500 * um, 2048)
wavelength = 1 * um
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.gauss_beam(A=1, x0=-100 * um, z0=150 * um, w0=15 * um, theta=0 * degrees)

u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)
u1.incident_field(u0)
u1.layer(r0=(50 * um, 0 * um), depth=100 * um, refractive_index=1.5, angle=60 * degrees)
u1.draw_refractive_index()
u1.smooth_refractive_index(type_filter=2, pixels_filtering=3)
```

```python
u1.BPM(verbose=False)
u1.draw(kind="intensity", logarithm=True, draw_borders=True)
```

```python
u1.draw(kind="intensity", logarithm=True, draw_borders=False)
plt.xlim(-100, 0)
plt.ylim(-125, -65)
```

--------------------------------

### Execute multiprocessing simulation

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/drawing/external_qt.ipynb

Setup the grating simulation environment and execute it using multiple processors.

```python
x0 = np.linspace(-400 * um, 400 * um, 1024 * 4)
wavelength = 0.85 * um
period = 50 * um
z_talbot = 2 * period**2 / wavelength
z0 = z_talbot / 2
delay = 0.001

t1 = Scalar_mask_X(x0, wavelength, info="__experiment_grating_movement__")
t1.ronchi_grating(period=period, x0=0 * um, fill_factor=0.5)
t1.RS(z=z0, new_field=False)

t2 = Scalar_mask_X(x0, wavelength, info="__experiment_grating_movement__")
t2.ronchi_grating(period=period, x0=0 * um, fill_factor=0.5)

deltas_x = np.linspace(-60 * um, 60 * um, 128)  # 512

dict_Parameters = creation_dictionary(deltas_x=deltas_x, period=period, t1=t1, t2=t2)

u_s, time_proc = execute_multiprocessing(
    __experiment_grating_movement__, dict_Parameters, num_processors=1, verbose=True
)

x = u_s[0].x
```

--------------------------------

### Scalar Mask and Lens Setup

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_vector/vector_grating_xy.ipynb

Defines the simulation grid and creates a Ronchi grating and a lens mask.

```python
num_data = 1024
length = 1*mm
x0 = np.linspace(-length / 2, length / 2, num_data)
y0 = np.linspace(-length / 2, length / 2, num_data)
wavelength = 2* um
period = 40*um
z_talbot = 2*period**2/wavelength

print(z_talbot)


t1 = Scalar_mask_XY(x0, y0, wavelength)
t1.ronchi_grating(x0=0, period=period, fill_factor=0.33, angle=0*degrees)
t1.draw(kind='intensity')


focal=2*mm
t_lens = Scalar_mask_XY(x0, y0, wavelength)
t_lens.lens(r0=(0 * um, 0 * um),
                radius=length/2,
                focal=focal)
t_lens.draw(kind='phase')
```

--------------------------------

### Initialize and simulate lens in XZ plane

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/drawing/external_qt.ipynb

Setup a plane wave source and a lens mask in the XZ plane, then perform surface detection.

```python
x0 = np.linspace(-200 * um, 200 * um, 512)
z0 = np.linspace(-100 * um, 600 * um, 512 * 4)
wavelength = 10 * um
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.plane_wave(A=1, theta=0 * degrees)
u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)
u1.incident_field(u0)
focal, _ = u1.lens(
    r0=(0 * um, 0 * um),
    size=300 * um,
    radii=(1000 * um, -250 * um),
    thickness=100 * um,
    refractive_index=2,
    angle=0 * degrees,
    mask=(10 * um, 3 + 5j),
)


u1.surface_detection()
```

--------------------------------

### Define spatial and wavelength parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/algorithms/BPM.ipynb

Sets up the spatial grid (x and z axes) and the wavelength for optical simulations. Ensure these parameters are consistent with the physical setup being modeled.

```python
x0 = np.linspace(-500 * um, 500 * um, 1024 * 4)
z0 = np.linspace(-0.1 * mm, 1.25 * mm, 1024 * 2)
wavelength = 5 * um
```

--------------------------------

### Simulate and Draw Aspheric Lens with Slit

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XZ/masks_xz.ipynb

Simulates an aspheric lens and a slit, then draws the refractive index. This example demonstrates calculating focal distance and visualizing the optical setup.

```python
x0 = np.linspace(-500 * um, 500 * um, 512)
z0 = np.linspace(-0.1 * mm, 1.25 * mm, 512)
wavelength = 5 * um

lens = Diffractio('scalar', 'mask', x=x0, z=z0, wavelength=wavelength, n_background=1, info="")
focal, ipasa = lens.aspheric_lens(
    r0=(0 * um, 0 * um),
    angle=(0 * degrees, (0 * um, 0 * um)),
    refractive_index=1.5,
    cx=(1 / (1 * mm), -1 / (0.5 * mm)),
    Qx=(0, 0),
    a2=(0, 1e-11),
    a3=(0, 0),
    a4=(0, 0),
    thickness=0.4 * mm,
    size=0.8 * mm,
)

lens.slit(r0=(0, 100 * um), aperture=800 * um, depth=75 * um, refractive_index=1 + 2j)

print("Theoretical image focal distance f' = {:2.2f} mm".format(focal/mm))

lens.draw_refractive_index(
    draw_borders=True, min_incr=0.01, colorbar_kind="vertical", scale='scaled'
)
```

--------------------------------

### Initialize WPM Environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/algorithms/WPM.ipynb

Import necessary modules and define the spatial and spectral parameters for the simulation.

```python
from diffractio import sp, nm, plt, np, mm, degrees, um
from diffractio.scalar_sources_X import Scalar_source_X
from diffractio.scalar_fields_XZ import Scalar_field_XZ
from diffractio.scalar_masks_XZ import Scalar_mask_XZ
from diffractio.scalar_masks_X import Scalar_mask_X

import matplotlib.cm as cm
```

```python
x0 = np.linspace(-500 * um, 500 * um, 1024 * 4)
z0 = np.linspace(-0.1 * mm, 1.25 * mm, 1024 * 2)
wavelength = 5 * um
```

--------------------------------

### Install Diffractio Stable Release

Source: https://github.com/optbrea/diffractio/blob/main/docs/installation.md

Use this command to install the latest stable version of the diffractio package via pip. This is the recommended installation method.

```console
# Linux:
$ pip3 install diffractio
```

```console
# Windows:
$ pip install diffractio
```

--------------------------------

### Install Jupyter Widgets

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/drawing/interactive_in_diffractio.ipynb

Shell commands to install necessary dependencies for interactive widgets.

```bash
pip3 install ipympl
```

```bash
pip3 install nodejs
```

```bash
jupyter labextension install @jupyter-widgets/jupyterlab-manager
```

```bash
jupyter labextension install jupyter-matplotlib
```

--------------------------------

### Initialize Source

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_advanced/scalar/ifta_CZT.ipynb

Sets up the source plane with a plane wave.

```python
source = Diffractio('scalar', 'source', **frame_in)
source.plane_wave()
```

--------------------------------

### GET /utils_optics/gauss_spectrum

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Returns weights for a Gaussian spectrum.

```APIDOC
## GET /utils_optics/gauss_spectrum

### Description
Returns weights for a gaussian spectrum.

### Parameters
#### Query Parameters
- **wavelengths** (NDArrayFloat) - Required - array with wavelengths
- **w_central** (float) - Required - central wavelength
- **Dw** (float) - Required - width of the spectrum
- **normalize** (bool) - Optional - if True sum of weights is 1 (default: True)
```

--------------------------------

### Initialize simulation environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/comparison/WPM_vs_BPM.ipynb

Imports necessary modules and defines the spatial and wavelength parameters for the simulation.

```python
from diffractio import plt, np, mm, degrees, um
from diffractio.scalar_sources_X import Scalar_source_X
from diffractio.scalar_masks_XZ import Scalar_mask_XZ
from matplotlib import cm
```

```python
x0 = np.linspace(-500 * um, 500 * um, 1024 * 4)
z0 = np.linspace(-0.1 * mm, 1.25 * mm, 1024 * 2)
wavelength = 25 * um

logarithm_drawing = 0
```

--------------------------------

### Get Date

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Retrieves the current date and time.

```APIDOC
## GET /diffractio/utils_common/get_date

### Description
Gets the current date and hour.

### Method
GET

### Endpoint
/diffractio/utils_common/get_date

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
* **date** (str) - The current date and time in text format.

#### Response Example
```json
{
  "date": "2023-10-27 10:30:00"
}
```
```

--------------------------------

### Initialize Environment and Sources

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_vector/algorithms/VCZT.ipynb

Imports necessary modules and sets up the initial scalar source and mask parameters.

```python
from diffractio import degrees, um
from diffractio import np

from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.scalar_sources_XY import Scalar_source_XY

from diffractio.vector_sources_XY import Vector_source_XY
```

```python
size = 25 * um
x0 = np.linspace(-size / 2, size / 2, 512)
y0 = np.linspace(-size / 2, size / 2, 256)

focal = 16 * um
wavelength = 0.6328 * um
```

```python
u0 = Scalar_source_XY(x0, y0, wavelength)
u0.gauss_beam(
    r0=(0 * um, 0 * um),
    w0=(32 * um, 32 * um),
    z0=0 * um,
    A=1,
    theta=0 * degrees,
    phi=0 * degrees,
)
```

```python
t = Scalar_mask_XY(x0, y0, wavelength)
t.lens_cylindrical(x0=0, focal=focal, angle=90 * degrees)
t.lens(r0=(0.0, 0.0), focal=focal)
```

```python
u1 = t * u0

EM1 = Vector_source_XY(x0, y0, wavelength)
EM1.constant_polarization(u=u1, v=(1, 1j))
EM1.pupil()
```

```python
EM1.draw("intensities", logarithm=0)
```

--------------------------------

### GET /utils_optics/convert_phase2heigths

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Converts phase values to physical depths.

```APIDOC
## GET /utils_optics/convert_phase2heigths

### Description
Phase is converted to a depth. Useful to convert Scalar_mask_X to Scalar_mask_XZ.

### Parameters
#### Query Parameters
- **phase** (np.array) - Required - Phases
- **wavelength** (float) - Required - wavelength
- **n** (float or complex) - Required - refractive index of material
- **n_background** (float) - Required - refractive index of background
```

--------------------------------

### GET /utils_optics/field_parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Determines main parameters of an optical field.

```APIDOC
## GET /utils_optics/field_parameters

### Description
Determines main parameters of field: amplitude, intensity, phase.

### Parameters
#### Query Parameters
- **u** (numpy.array) - Required - optical field
- **has_amplitude_sign** (bool) - Optional - If True, amplitude = np.sign(u) * np.abs(u) (default: False)
```

--------------------------------

### Setup for Video Generation of Gaussian Beam Through a Circular Aperture

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XYZ/tutorial_xyz.ipynb

Initializes a Gaussian beam and a circular aperture mask for creating a video of the field evolution. Uses Scalar_source_XY and Scalar_mask_XY.

```python
length = 50 * um
numdata = 128  # 256
x0 = np.linspace(-length / 2, length / 2, numdata)
y0 = np.linspace(-length / 2, length / 2, numdata)
z0 = np.linspace(50 * um, 2 * mm, 250)  # 128
wavelength = 0.5 * um

u1 = Scalar_source_XY(x=x0, y=y0, wavelength=wavelength)
u1.gauss_beam(A=1, r0=(0 * um, 0 * um), z0=0, w0=(150 * um, 150 * um))

t1 = Scalar_mask_XY(x=x0, y=y0, wavelength=wavelength)
t1.circle(r0=(0 * um, 0 * um), radius=25*um)
t3 = u1 * t1
```

--------------------------------

### Setup far-field DOE

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/fresnel_lens.ipynb

Initialize the XZ mask for far-field propagation.

```python
n_lens = 1.5
n_background = 1.33
k = 2 * np.pi / wavelength
desfase = np.pi
height_lens = abs(desfase / (k * (n_lens - n_background)))
z_ini = 1 * mm

DOE_far = Scalar_mask_XZ( x=x0_far, z=z0_far, wavelength=wavelength, n_background=n_background)
DOE_far.incident_field(u0 * t0)
```

--------------------------------

### Define lens parameters and initial source

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_advanced/scalar/lenses.ipynb

Set up the physical parameters for the lens and the initial light source. This includes focal length, diameter, wavelength, and the spatial grid for the simulation.

```python
focal = 25 * mm
diameter = 4 * mm

# Initial parameters
x0 = np.linspace(-diameter / 2 - 50 * um, diameter / 2 + 50 * um, 1024 * 32)
wavelength = 0.6238 * um

# Definition of source
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.plane_wave(A=1)

t0 = Scalar_mask_X(x=x0, wavelength=wavelength)
t0.lens(x0=0.0, focal=focal, radius=diameter / 2)
```

--------------------------------

### refractive_index_from_scalarXY

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Gets the refractive index from a Scalar field and passes it to a vector field.

```APIDOC
## refractive_index_from_scalarXY

### Description
Gets the refractive index from a Scalar field and passes to a vector field. The refractive index is isotropic.

### Parameters
#### Request Body
- **u_xy** (Scalar_mask_XY) - Required - Scalar_mask_XY
```

--------------------------------

### Initialize 1D grating parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/blazed_grating.ipynb

Sets up the wavelength, focal length, and spatial grid for the 1D simulation.

```python
wavelength = 1*um
focal = 5*mm

x = np.linspace(-3500,3500,2048*8)
```

--------------------------------

### GET /utils_optics/lines_mm_2_cycles_degree

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Converts lines per millimeter to cycles per degree.

```APIDOC
## GET /utils_optics/lines_mm_2_cycles_degree

### Description
Converts lines/mm to cycles/degree.

### Parameters
#### Query Parameters
- **lines_mm** (ndarray or float) - Required - lines_per_mm
- **focal** (float) - Required - focal of lens
```

--------------------------------

### Initialize Diffractio Environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/focal_shift.ipynb

Imports necessary modules and units for scalar diffraction simulations.

```python
from diffractio import um, mm
from diffractio import plt, np
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.scalar_sources_XY import Scalar_source_XY
```

--------------------------------

### Get Cut Frequency

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Calculates the cut-off frequency of a lens based on its parameters.

```APIDOC
## diffractio.utils_optics.get_cut_frequency

### Description
Determines the cut frequency of a lens.

### Parameters
#### Path Parameters
- **wavelength** (float) - Required - wavelength of incoming light beam
- **diameter** (float) - Required - diameter of lens
- **focal** (float) - Required - focal distance of lens

### Returns
- **freq_cut** (float) - maximum frequency of the lens.
```

--------------------------------

### Initialize simulation parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_vector/vector_XZ/tutorial_vector_XZ.ipynb

Sets up spatial dimensions, wavelength, and refractive index for the simulation. Defines the grid for the XZ plane.

```python
lateral_x = 0.15 * um
diameter = 5 * um
size = 1 * diameter
length_z = 1.5 * diameter
refractive_index=1.65

x0 = np.linspace(-size / 2 - lateral_x, size / 2 + lateral_x, 1024)
z0 = np.linspace(0 * um, length_z, 1024)
wavelength = 0.6328 * um

frame_x = dict(x=x0, wavelength=wavelength)
frame_xz = dict(x=x0, z=z0, wavelength=wavelength)

EH_xz = Diffractio('vector', 'field', **frame_xz)

scale='scaled'
logarithm=1e0
ms=0.5
```

--------------------------------

### Setting initial simulation parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/drawing/use_interact_visualize_profiles.ipynb

Define spatial coordinates and wavelength for the simulation.

```python
# Initial parameters
x0 = np.linspace(-1050 * um, 1050 * um, 1024 * 2)
z0 = np.linspace(-0.125 * um, 4 * mm, 1024 * 4)
wavelength = 0.6238 * um * 10
```

--------------------------------

### Focus Position Output

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XY/tutorial_xy.ipynb

Example output showing the detected focus coordinates.

```text
x = -0.283 um, y = -0.283 um
```

--------------------------------

### Simulation Output

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/talbot_effect.ipynb

Example output showing performance metrics for the multiprocessing execution.

```text
Output:
Good result: factor 4.00
num_proc: 1, time=0.01840353012084961
```

--------------------------------

### GET /utils_optics/MTF_parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Calculates MTF parameters including Strehl ratio and frequency comparisons.

```APIDOC
## GET /utils_optics/MTF_parameters

### Description
Calculates MTF parameters: strehl_ratio, mtf_50_ratio, freq_50_real, freq_50_ideal.

### Parameters
#### Query Parameters
- **MTF** (numpy.array) - Required - (freq, MTF) of system in lines/mm
- **MTF_ideal** (numpy.array) - Required - (freq, MTF) of ideal system in lines/mm
- **lines_mm** (float) - Optional - Height of MTF for ratios (default: 50)
- **verbose** (bool) - Optional - Verbose output (default: False)
```

--------------------------------

### Initialize Scalar Source and Lens with BPM

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/artifacts_bpm.ipynb

Sets up a scalar source and a lens, then calculates the focal plane using BPM. This is useful for simulating basic optical systems.

```python
x0 = np.linspace(-200*um, 200*um, 512)
z0 = np.linspace(-100*um, 600*um, 512 * 4)
wavelength = 0.6238*um
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.plane_wave(A=1, theta=0*degrees)
u0.gauss_beam(A=1, x0=0*um, z0=0*um, w0=200*um, theta=0*degrees)
u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)
u1.incident_field(u0)
focal, _ = u1.lens(r0=(0*um, 0*um),
                              size=300*um,
                              radii=(1000*um, -250*um),
                              thickness=100*um,
                              refractive_index=2,
                              angle=0*degrees,
                              mask=(10*um, 3 + 0.05j))
u1.clear_field()

print(focal)

```

--------------------------------

### Initialize Diffractio Environment

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XYZ/masks_xyz.ipynb

Imports necessary modules and configures the PyVista backend for visualization.

```python
from diffractio import degrees, np, um, mm
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.scalar_masks_XYZ import Scalar_mask_XYZ
```

```python
# change to pv.set_jupyter_backend('trame') for dynamic images.
import pyvista as pv
pv.set_jupyter_backend('static')
```

--------------------------------

### Configure far-field lens mask

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/fresnel_lens.ipynb

Define the Fresnel lens parameters for the far-field setup.

```python
size_lens = 3.8 * mm
t0.fresnel_lens(x0=0.0 * um, focal=15 * mm, kind="amplitude", phase=np.pi, radius=size_lens / 2)
```

--------------------------------

### Define Simulation Grid and Parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XYZ/wpm_without_storing.ipynb

Sets up the spatial grid (x, y, z) and simulation parameters like wavelength and observation distance.

```python
num_z = 256

x = np.linspace(-50 * um, 50 * um, 256)
y = np.linspace(-50 * um, 50 * um, 256)
z = np.linspace(0, 101 * um, num_z)
z_obs = z[-1]
wavelength = 5 * um
```

--------------------------------

### Set Propagation Start Position

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/WPM_ws.ipynb

Defines the initial z-position for the field propagation calculation.

```python
z_pos = 0.1*mm
```

--------------------------------

### Get intensity values

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/algorithms/BPM.ipynb

Extracts the intensity values from the propagated field. This can be used for further quantitative analysis.

```python
Intensity_BPM = lens.intensity()
```

--------------------------------

### Initialize XY Framework Imports

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/arago_point.ipynb

Required imports for setting up scalar diffraction simulations in the XY plane.

```python
from diffractio import np, plt, um, mm, nm, degrees
from diffractio.scalar_masks_XY import Scalar_mask_XY
from diffractio.scalar_sources_XY import Scalar_source_XY
```

--------------------------------

### Get Frequency at MTF Level

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_advanced/scalar/MTF.ipynb

Determines the frequency at which the MTF drops to a specific threshold value.

```python
level = 0.5
MTF_frec = get_MTF_frequency(fr, mtf_rad, level= level, has_draw=True, verbose=True)
plt.xlim(0,80)
```

--------------------------------

### Importing Fresnel modules

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/other/fresnel_equations.ipynb

Initial setup for importing necessary libraries and Fresnel calculation functions.

```python
import numpy as np
import matplotlib.pyplot as plt

from diffractio import um, mm, degrees
from diffractio.utils_optics import (
    fresnel_equations_kx,
    fresnel_equations,
    transmitances_reflectances_kx,
    transmitances_reflectances,
)
```

--------------------------------

### Define Simulation Parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/focal_shift.ipynb

Sets up the spatial grid and wavelength for the simulation.

```python
x0=np.linspace(-1000*um, 1000*um, 512)
y0=np.linspace(-1000*um, 1000*um, 512)
wavelength = 0.6328*um
```

```python
x0=np.linspace(-100*um, 100*um, 512)
y0=np.linspace(-100*um, 100*um, 512)
wavelength = 0.6328*um
```

--------------------------------

### Vector Source Initialization

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_vector/vector_grating_xy.ipynb

Sets up a vector source with specific polarization and wave properties.

```python
u0 = Scalar_source_XY(x0, y0, wavelength)
u0.vortex_beam(A=1, r0=(0,0), w0=100*um, m=1)
u0.plane_wave(A=1)
u0.pupil()


E0 = Vector_source_XY(x0, y0, wavelength)
E0.constant_polarization(u=u0, v=(1, 1j))
E0.azimuthal_wave(u=u0, r0=(0, 0))
E0.radial_wave(u=u0, r0=(0, 0))
E0.draw('stokes')
```

--------------------------------

### Define simulation parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/quality_factor.ipynb

Sets up the initial parameters for the simulation, including wavelength, grid dimensions, and spatial range.

```python
wavelength = 0.5*um
num_x = 512
num_y = 512
range_x=1*mm
range_y=1*mm
x0 = np.linspace(-range_x/2, range_x/2, num_x)
y0 = np.linspace(-range_y/2, range_y/2, num_y)
```

--------------------------------

### prepare_video

Source: https://github.com/optbrea/diffractio/blob/main/docs/diffractio.md

Initializes video recording parameters.

```APIDOC
## POST /optbrea/diffractio/utils_drawing/prepare_video

### Description
Initializes video recording parameters.

### Method
POST

### Endpoint
/optbrea/diffractio/utils_drawing/prepare_video

### Parameters
#### Query Parameters
- **fps** (int) - Optional - Frames per second for the video. Defaults to 15.
- **title** (str) - Optional - Title for the video. Defaults to "".
- **artist** (str) - Optional - Artist information for the video. Defaults to "".
- **comment** (str) - Optional - Comment for the video. Defaults to "".

### Response
#### Success Response (200)
- **_description_** (str) - Description of the return value.
- **_type_** (str) - The type of the return value.

#### Response Example
```json
{
  "_description_": "Video preparation successful.",
  "_type_": "void"
}
```
```

--------------------------------

### Define 2D lens system

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/comparison/CZT_vs_RS.ipynb

Setup of a 2D plane wave source and lens mask.

```python
diameter = 2 * mm
focal = 25 * mm

x0 = np.linspace(-diameter / 2, diameter / 2, 1024)
y0 = np.linspace(-diameter / 2, diameter / 2, 1024)
wavelength = 0.6238 * um
```

```python
u0 = Scalar_source_XY(x=x0, y=y0, wavelength=wavelength)
u0.plane_wave()

t0 = Scalar_mask_XY(x=x0, y=y0, wavelength=wavelength)
t0.lens(r0=(0 * um, 0 * um), radius=(diameter / 2, diameter / 2), focal=(focal, focal))

t0.draw("phase", percentage_intensity=0.01)

u1 = u0 * t0
```

--------------------------------

### Simulate propagation using Wave Propagation Method (WPM)

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/comparison/RS_vs_WPM.ipynb

Initializes another Scalar_field_XZ object, sets the incident field, applies the WPM method, and draws the normalized intensity profile.

```python
u_wpm = Scalar_field_XZ(x=x0, z=z0, wavelength=wavelength)
u_wpm.incident_field(f1)
u_wpm.WPM(verbose=False)
u_wpm.draw(
    kind="intensity", logarithm=False, normalize="intensity", colorbar_kind="vertical"
)
```

--------------------------------

### Initialize Beam Propagation Method

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XZ/tutorial_xz.ipynb

Sets up the initial scalar source and defines the XZ mask geometry for BPM simulations.

```python
x0 = np.linspace(-100*um, 100*um, 1024)
z0 = np.linspace(0*um, 200*um, 1024)
wavelength = 5*um

u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.gauss_beam(A=1, x0=0*um, z0=0*um, w0=10*um, theta=0*degrees)
u0.plane_wave(A=1, theta=0*degrees)
```

```python
u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)
u1.incident_field(u0)
u1.square(r0=(0*um, 100*um),
             size=(75*um, 75*um),
             angle=45*degrees,
             refractive_index=1.5)
u1.draw_refractive_index(scale='scaled')
```

--------------------------------

### Define spatial and wavelength parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/partial_coherent_source.ipynb

Setup of coordinate arrays and frame dictionaries for field calculations.

```python
x0 = np.linspace(-150 * um, 150 * um, 256)
y0 = np.linspace(-150 * um, 150 * um, 256)
z0 = np.linspace(0, 100*um, 512)
wavelength = 2 * um
k = 2 * np.pi / wavelength


frame_xy = dict(x=x0, y=y0, wavelength=wavelength)
frame_xyz = dict(x=x0, y=y0, z=z0, wavelength=wavelength)
```

--------------------------------

### Define Spatial and Wavelength Parameters in Python

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/developing_new_functions.ipynb

Sets up the spatial grid (x0, y0) and the wavelength for optical simulations.

```python
x0 = np.linspace(-500*um, 500*um, 256)
y0 = np.linspace(-500*um, 500*um, 256)
wavelength = 0.6328*um
```

--------------------------------

### Execute Wave Propagation Method (WPM)

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_XZ/tutorial_xz.ipynb

Demonstrates incremental propagation through a square mask using WPM, including surface detection and visualization.

```python
x0 = np.linspace(-100*um, 100*um, 512)
z0 = np.linspace(0*um, 200*um, 512)
wavelength = 5*um

u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.gauss_beam(A=1, x0=0*um, z0=0*um, w0=10*um, theta=0*degrees)
u0.plane_wave(A=1, theta=0*degrees)
```

```python
u1 = Scalar_mask_XZ(x=x0, z=z0, wavelength=wavelength)
u1.incident_field(u0)
u1.square(r0=(0*um, 100*um),
             size=(75*um, 75*um),
             angle=45*degrees,
             refractive_index=1.5)
u1.draw_refractive_index(scale='scaled')
```

```python
edges = u1.surface_detection()
```

```python
u1.WPM(verbose=False, has_edges=False)
u1.draw(logarithm=True,
        normalize='maximum',
        draw_borders=True,
        edge_matrix=edges,
        scale='scaled')
```

--------------------------------

### Define Simulation Parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/functioning/WPM_ws.ipynb

Sets up the spatial grid (x, y, z) and wavelength for the simulation. It also calculates and prints the grid spacing and their ratios to the wavelength.

```python
# Parameters

num_z = 128
x = np.linspace(-30*um, 30*um, 512)
y = np.linspace(-30*um, 30*um, 512)
z = np.linspace(0, 60*um, num_z)
wavelength = 2*um

dx = x[1] - x[0]
dy = y[1] - y[0]
dz = z[1] - z[0]

print("x = {:2.5f}, x = {:2.5f}, z = {:2.2f}".format(dx, dy, dz))
print("x/l = {:2.2f}, y/l = {:2.2f}, z/l = {:2.2f}".format(
    dx / wavelength, dy / wavelength, dz / wavelength))
```

--------------------------------

### Defining spatial and physical parameters

Source: https://github.com/optbrea/diffractio/blob/main/test_jupyter/test_Diffractio.ipynb

Setup of coordinate arrays and physical constants required for field initialization.

```python
x = np.linspace(-10 * um, 10 * um, 100)
y = np.linspace(-10 * um, 10 * um, 100)
z = np.linspace(-10 * um, 10 * um, 100)

x_none = None
y_none = None
z_none = None

wavelength = 0.6328 * um
info = "Test"
```

--------------------------------

### Setup Optical System for MTF

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/scalar_X/tutorial_x.ipynb

Define the plane wave source and lens mask for MTF calculation.

```python
num_data = 1024 * 4
x = np.linspace(-500 * um, 500 * um, num_data)
wavelength = 0.6328 * um

# intensidad de una onda plana
u0 = Scalar_source_X(x, wavelength)
u0.plane_wave()

lens = Scalar_mask_X(x, wavelength)
focal = 10 * mm
lens.lens(x0=0, focal=focal)
```

--------------------------------

### Define 1D lens system

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/tutorial_scalar/comparison/CZT_vs_RS.ipynb

Setup of a plane wave source and a lens mask for 1D simulation.

```python
focal = 25 * mm
diameter = 4 * mm

# Initial parameters
x0 = np.linspace(-diameter / 2 - 50 * um, diameter / 2 + 50 * um, 4096)
wavelength = 0.6238 * um

# Definition of source
u0 = Scalar_source_X(x=x0, wavelength=wavelength)
u0.plane_wave(A=1)

t0 = Scalar_mask_X(x=x0, wavelength=wavelength)
t0.lens(x0=0.0, focal=focal, radius=diameter / 2)

u1 = t0 * u0
```

--------------------------------

### Initialize 2D grating parameters

Source: https://github.com/optbrea/diffractio/blob/main/docs/source/examples_scalar/blazed_grating.ipynb

Sets up parameters for a 2D simulation, including pixel count, length, spatial grids, wavelength, and focal length.

```python
num_pixels = 1024

length = 500*um
x0 = np.linspace(-length/2, length/2, 2*num_pixels)
y0 = np.linspace(-length/2, length/2, num_pixels)
wavelength = 0.6238*um

focal = 5*mm
```