gspat

gspat is an algorithm that speeds up gs. The algorithm is based on the paper by Plasencia et al. (Plasencia et al., 2020).

API

Rust

gspat(
    &NalgebraBackend,
    &geometry,
    &foci,
    wavelength,
    &option,
    &mut dst,
)?;

Python

gspat(geometry, foci, wavelength, option, dst)

C#

Holo.Gspat(geometry, foci, wavelength, option, dst);

Parameter	Type	Description
geometry	&Geometry	Device layout
foci	&[AmplitudeTarget]	Sequence of focal points (position and target amplitude)
wavelength	Length	Wavelength
option	&GspatOption	Additional options (see below)
dst	&mut [[Emission; _]]	Output buffer

The parameters are the same as gs.

GspatOption

Rust

GspatOption {
    repeat,
    constraint,
    directivity,
    mask,
    parallel,
}

Python

GspatOption(
    repeat,
    constraint,
    directivity,
    mask,
    parallel,
)

C#

new GspatOption(
    repeat,
    constraint,
    directivity,
    mask,
    parallel
)

Field	Type	Default
repeat	NonZeroUsize	100
constraint	EmissionConstraint	Clamp(MIN, MAX)
directivity	Directivity	Sphere
mask	TransducerMask	AllEnabled
parallel	bool	true

The options are the same as gs.

parallel decides whether the quantization of the result is spread over several host threads (a GPU backend ignores it).

Example

Rust

use std::num::NonZeroUsize;

use autd3_rs::geometry::{Autd3, Geometry, 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, EmissionConstraint, GspatOption, NalgebraBackend, Pa,
    TransducerMask, gspat,
};

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

let mut dst = geometry.pattern_buffer();

gspat(
    &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),
    &GspatOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: EmissionConstraint::Clamp(Intensity::MIN, Intensity::MAX),
        directivity: Directivity::Sphere,
        mask: TransducerMask::AllEnabled,
        parallel: true,
    },
    &mut dst,
)?;

Python

import numpy as np
from autd3.geometry import Autd3, Geometry
from autd3.units import m, s
from autd3_pattern import wavelength
from autd3_pattern_holo import (
    AmplitudeTarget,
    Directivity,
    EmissionConstraint,
    GspatOption,
    Pa,
    TransducerMask,
    gspat,
)

geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])

dst = geometry.pattern_buffer()

gspat(
    geometry,
    [
        AmplitudeTarget(
            point=geometry.center() + np.array([-30.0, 0.0, 150.0]),
            amplitude=2.5e3 * Pa,
        ),
        AmplitudeTarget(
            point=geometry.center() + np.array([30.0, 0.0, 150.0]),
            amplitude=2.5e3 * Pa,
        ),
    ],
    wavelength(340 * m / s),
    GspatOption(
        repeat=100,
        constraint=EmissionConstraint.Clamp(0x00, 0xFF),
        directivity=Directivity.Sphere,
        mask=TransducerMask.AllEnabled,
    ),
    dst,
)

C#

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

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

var dst = geometry.PatternBuffer();

Holo.Gspat(
    geometry,
    new[]
    {
        new AmplitudeTarget(geometry.Center + new Vector3(-30.0f, 0.0f, 150.0f), 2.5e3f * Pa),
        new AmplitudeTarget(geometry.Center + new Vector3(30.0f, 0.0f, 150.0f), 2.5e3f * Pa),
    },
    Pattern.Wavelength(340.0f * m / s),
    new GspatOption(
        repeat: 100,
        constraint: EmissionConstraint.Clamp(Intensity.Min, Intensity.Max),
        directivity: Directivity.Sphere,
        mask: TransducerMask.AllEnabled
    ),
    dst
);