gs

gs (Gerchberg-Saxton method) is an algorithm that iterates forward-propagation and back-propagation while alternately imposing amplitude constraints on the transducer side and the focal-point side. It suppresses interference between focal points better than naive, but the amount of computation increases with the number of iterations. The algorithm is based on the paper by Marzo et al. (Marzo & Drinkwater, 2019).

API

Rust

gs(
    &NalgebraBackend,
    &geometry,
    &foci,
    wavelength,
    &option,
    &mut phases,
    &mut intensities,
)?;

Python

gs(geometry, foci, wavelength, option, phases, intensities)

C#

Holo.Gs(geometry, foci, wavelength, option, phases, intensities);

Parameter	Type	Description
geometry	&Geometry	Device layout
foci	&[AmplitudeTarget]	Sequence of focal points (position and target amplitude)
wavelength	Length	Wavelength
option	&GsOption	Additional options (see below)
phases	&mut [Vec<Phase>]	Phase output buffer
intensities	&mut [Vec<Intensity>]	Intensity output buffer

GsOption

Rust

GsOption {
    repeat,
    constraint,
    directivity,
    mask,
}

Python

GsOption(
    repeat,
    constraint,
    directivity,
    mask,
)

C#

new GsOption
{
    Repeat = repeat,
    Constraint = constraint,
    Directivity = directivity,
    Mask = mask,
}

Field	Type	Default
repeat	NonZeroUsize	100
constraint	IntensityConstraint	Clamp(MIN, MAX)
directivity	Directivity	Sphere
mask	TransducerMask	AllEnabled

repeat is the number of iterations. The larger it is, the higher the quality, but the more computation time increases.

Example

Rust

use std::num::NonZeroUsize;

use autd3_rs::geometry::{Autd3, Geometry, TransducerMask, offset};
use autd3_rs::units::{m, mm, s};
use autd3_rs::value::Intensity;
use autd3_rs_pattern::wavelength;
use autd3_rs_pattern_holo::{
    AmplitudeTarget, Directivity, IntensityConstraint, GsOption, NalgebraBackend, Pa, gs,
};

let geometry = Geometry::new(vec![Autd3::default()]);

let mut phases = geometry.phase_buffer();
let mut intensities = geometry.intensity_buffer();

gs(
    &NalgebraBackend,
    &geometry,
    &[
        AmplitudeTarget {
            point: geometry.center() + offset(-30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude: 2.5e3 * Pa,
        },
        AmplitudeTarget {
            point: geometry.center() + offset(30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude: 2.5e3 * Pa,
        },
    ],
    wavelength(340.0 * m / s),
    &GsOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: IntensityConstraint::Clamp(Intensity::MIN, Intensity::MAX),
        directivity: Directivity::Sphere,
        mask: TransducerMask::AllEnabled,
    },
    &mut phases,
    &mut intensities,
)?;

Python

from autd3.geometry import Autd3, Geometry, offset
from autd3.units import m, mm, s
from autd3.value import Intensity
from autd3_pattern import TransducerMask, wavelength
from autd3_pattern_holo import (
    AmplitudeTarget,
    Directivity,
    IntensityConstraint,
    GsOption,
    Pa,
    gs,
)

geometry = Geometry([Autd3()])

phases = geometry.phase_buffer()
intensities = geometry.intensity_buffer()

gs(
    geometry,
    [
        AmplitudeTarget(
            point=geometry.center() + offset(-30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude=2.5e3 * Pa,
        ),
        AmplitudeTarget(
            point=geometry.center() + offset(30.0 * mm, 0.0 * mm, 150.0 * mm),
            amplitude=2.5e3 * Pa,
        ),
    ],
    wavelength(340 * m / s),
    GsOption(
        repeat=100,
        constraint=IntensityConstraint.Clamp(Intensity.MIN, Intensity.MAX),
        directivity=Directivity.Sphere,
        mask=TransducerMask.AllEnabled,
    ),
    phases,
    intensities,
)

C#

using AUTD3;
using AUTD3.Holo;
using static AUTD3.Units;
using static AUTD3.Holo.HoloUnits;

var geometry = new Geometry(new[] { new Autd3() });

var phases = geometry.PhaseBuffer();
var intensities = geometry.IntensityBuffer();

Holo.Gs(
    geometry,
    new[]
    {
        new AmplitudeTarget(geometry.Center + Offset(-30.0f * mm, 0.0f * mm, 150.0f * mm), 2.5e3f * Pa),
        new AmplitudeTarget(geometry.Center + Offset(30.0f * mm, 0.0f * mm, 150.0f * mm), 2.5e3f * Pa),
    },
    Pattern.Wavelength(340.0f * m / s),
    new GsOption
    {
        Repeat = 100,
        Constraint = IntensityConstraint.Clamp(Intensity.Min, Intensity.Max),
        Directivity = Directivity.Sphere,
        Mask = TransducerMask.AllEnabled,
    },
    phases,
    intensities
);